void/AyuGramDesktop
2
0
Fork 0
mirror of https://github.com/AyuGram/AyuGramDesktop.git synced 2025-06-05 06:33:57 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Made base::lambda a copyable value type.

Browse source 
Now base::lambda can be copied and can wrap any immutable lambda.
For mutable lambdas there is base::lambda_once (which you're
supposed to call only once to pass data through lambda captures,
for example by using std::unique_ptr). Generally base::lambda is
passed by value and base::lambda_once is passed by rvalue reference.
This commit is contained in:
John Preston 2017-02-26 14:32:13 +03:00
parent f82989c9c3
commit c207743338
78 changed files with 662 additions and 633 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Telegram/SourceFiles/apiwrap.cpp
View file

@ -44,7 +44,7 @@ ApiWrap::ApiWrap(QObject *parent) : QObject(parent)
void ApiWrap::init() { void ApiWrap::init() {
} }
void ApiWrap::requestMessageData(ChannelData *channel, MsgId msgId, const RequestMessageDataCallback &callback) { void ApiWrap::requestMessageData(ChannelData *channel, MsgId msgId, RequestMessageDataCallback callback) {
MessageDataRequest &req(channel ? _channelMessageDataRequests[channel][msgId] : _messageDataRequests[msgId]); MessageDataRequest &req(channel ? _channelMessageDataRequests[channel][msgId] : _messageDataRequests[msgId]);
if (callback) { if (callback) {
req.callbacks.append(callback); req.callbacks.append(callback);

4
Telegram/SourceFiles/apiwrap.h
View file

@ -41,8 +41,8 @@ public:
ApiWrap(QObject *parent); ApiWrap(QObject *parent);
void init(); void init();
using RequestMessageDataCallback = base::lambda_copy<void(ChannelData*, MsgId)>; using RequestMessageDataCallback = base::lambda<void(ChannelData*, MsgId)>;
void requestMessageData(ChannelData *channel, MsgId msgId, const RequestMessageDataCallback &callback); void requestMessageData(ChannelData *channel, MsgId msgId, RequestMessageDataCallback callback);
void requestFullPeer(PeerData *peer); void requestFullPeer(PeerData *peer);
void requestPeer(PeerData *peer); void requestPeer(PeerData *peer);

8
Telegram/SourceFiles/boxes/abstractbox.cpp
View file

@ -33,11 +33,11 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
BoxLayerTitleShadow::BoxLayerTitleShadow(QWidget *parent) : Ui::PlainShadow(parent, st::boxLayerTitleShadow) { BoxLayerTitleShadow::BoxLayerTitleShadow(QWidget *parent) : Ui::PlainShadow(parent, st::boxLayerTitleShadow) {
} }
QPointer<Ui::RoundButton> BoxContent::addButton(const QString &text, base::lambda<void()> &&clickCallback) { QPointer<Ui::RoundButton> BoxContent::addButton(const QString &text, base::lambda<void()> clickCallback) {
return addButton(text, std::move(clickCallback), st::defaultBoxButton); return addButton(text, std::move(clickCallback), st::defaultBoxButton);
} }
QPointer<Ui::RoundButton> BoxContent::addLeftButton(const QString &text, base::lambda<void()> &&clickCallback) { QPointer<Ui::RoundButton> BoxContent::addLeftButton(const QString &text, base::lambda<void()> clickCallback) {
return getDelegate()->addLeftButton(text, std::move(clickCallback), st::defaultBoxButton); return getDelegate()->addLeftButton(text, std::move(clickCallback), st::defaultBoxButton);
} }
@ -310,7 +310,7 @@ void AbstractBox::clearButtons() {
_leftButton.destroy(); _leftButton.destroy();
} }
QPointer<Ui::RoundButton> AbstractBox::addButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) { QPointer<Ui::RoundButton> AbstractBox::addButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) {
_buttons.push_back(object_ptr<Ui::RoundButton>(this, text, st)); _buttons.push_back(object_ptr<Ui::RoundButton>(this, text, st));
auto result = QPointer<Ui::RoundButton>(_buttons.back()); auto result = QPointer<Ui::RoundButton>(_buttons.back());
result->setClickedCallback(std::move(clickCallback)); result->setClickedCallback(std::move(clickCallback));
@ -319,7 +319,7 @@ QPointer<Ui::RoundButton> AbstractBox::addButton(const QString &text, base::lamb
return result; return result;
} }
QPointer<Ui::RoundButton> AbstractBox::addLeftButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) { QPointer<Ui::RoundButton> AbstractBox::addLeftButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) {
_leftButton = object_ptr<Ui::RoundButton>(this, text, st); _leftButton = object_ptr<Ui::RoundButton>(this, text, st);
auto result = QPointer<Ui::RoundButton>(_leftButton); auto result = QPointer<Ui::RoundButton>(_leftButton);
result->setClickedCallback(std::move(clickCallback)); result->setClickedCallback(std::move(clickCallback));

14
Telegram/SourceFiles/boxes/abstractbox.h
View file

@ -43,8 +43,8 @@ public:
virtual void setTitle(const QString &title, const QString &additional) = 0; virtual void setTitle(const QString &title, const QString &additional) = 0;
virtual void clearButtons() = 0; virtual void clearButtons() = 0;
virtual QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) = 0; virtual QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) = 0;
virtual QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) = 0; virtual QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) = 0;
virtual void updateButtonsPositions() = 0; virtual void updateButtonsPositions() = 0;
virtual void setDimensions(int newWidth, int maxHeight) = 0; virtual void setDimensions(int newWidth, int maxHeight) = 0;
@ -98,9 +98,9 @@ protected:
void clearButtons() { void clearButtons() {
getDelegate()->clearButtons(); getDelegate()->clearButtons();
} }
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> &&clickCallback); QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> clickCallback);
QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> &&clickCallback); QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> clickCallback);
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) { QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) {
return getDelegate()->addButton(text, std::move(clickCallback), st); return getDelegate()->addButton(text, std::move(clickCallback), st);
} }
void updateButtonsGeometry() { void updateButtonsGeometry() {
@ -187,8 +187,8 @@ public:
void setTitle(const QString &title, const QString &additional) override; void setTitle(const QString &title, const QString &additional) override;
void clearButtons() override; void clearButtons() override;
QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) override; QPointer<Ui::RoundButton> addButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) override;
QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> &&clickCallback, const style::RoundButton &st) override; QPointer<Ui::RoundButton> addLeftButton(const QString &text, base::lambda<void()> clickCallback, const style::RoundButton &st) override;
void updateButtonsPositions() override; void updateButtonsPositions() override;
void setDimensions(int newWidth, int maxHeight) override; void setDimensions(int newWidth, int maxHeight) override;

2
Telegram/SourceFiles/boxes/addcontactbox.cpp
View file

@ -1111,7 +1111,7 @@ void EditChannelBox::onSaveSignDone(const MTPUpdates &updates) {
closeBox(); closeBox();
} }
RevokePublicLinkBox::RevokePublicLinkBox(QWidget*, base::lambda<void()> &&revokeCallback) RevokePublicLinkBox::RevokePublicLinkBox(QWidget*, base::lambda<void()> revokeCallback)
: _rowHeight(st::contactsPadding.top() + st::contactsPhotoSize + st::contactsPadding.bottom()) : _rowHeight(st::contactsPadding.top() + st::contactsPhotoSize + st::contactsPadding.bottom())
, _revokeWidth(st::normalFont->width(lang(lng_channels_too_much_public_revoke))) , _revokeWidth(st::normalFont->width(lang(lng_channels_too_much_public_revoke)))
, _aboutRevoke(this, lang(lng_channels_too_much_public_about), Ui::FlatLabel::InitType::Simple, st::aboutRevokePublicLabel) , _aboutRevoke(this, lang(lng_channels_too_much_public_about), Ui::FlatLabel::InitType::Simple, st::aboutRevokePublicLabel)

2
Telegram/SourceFiles/boxes/addcontactbox.h
View file

@ -278,7 +278,7 @@ private:
class RevokePublicLinkBox : public BoxContent, public RPCSender { class RevokePublicLinkBox : public BoxContent, public RPCSender {
public: public:
RevokePublicLinkBox(QWidget*, base::lambda<void()> &&revokeCallback); RevokePublicLinkBox(QWidget*, base::lambda<void()> revokeCallback);
protected: protected:
void prepare() override; void prepare() override;

2
Telegram/SourceFiles/boxes/backgroundbox.h
View file

@ -46,7 +46,7 @@ class BackgroundBox::Inner : public TWidget, public RPCSender, private base::Sub
public: public:
Inner(QWidget *parent); Inner(QWidget *parent);
void setBackgroundChosenCallback(base::lambda<void(int index)> &&callback) { void setBackgroundChosenCallback(base::lambda<void(int index)> callback) {
_backgroundChosenCallback = std::move(callback); _backgroundChosenCallback = std::move(callback);
} }

18
Telegram/SourceFiles/boxes/confirmbox.cpp
View file

@ -41,7 +41,7 @@ TextParseOptions _confirmBoxTextOptions = {
Qt::LayoutDirectionAuto, // dir Qt::LayoutDirectionAuto, // dir
}; };
ConfirmBox::ConfirmBox(QWidget*, const QString &text, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback) ConfirmBox::ConfirmBox(QWidget*, const QString &text, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(lang(lng_box_ok)) : _confirmText(lang(lng_box_ok))
, _cancelText(lang(lng_cancel)) , _cancelText(lang(lng_cancel))
, _confirmStyle(st::defaultBoxButton) , _confirmStyle(st::defaultBoxButton)
@ -51,7 +51,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, base::lambda<void()> &&con
init(text); init(text);
} }
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback) ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(confirmText) : _confirmText(confirmText)
, _cancelText(lang(lng_cancel)) , _cancelText(lang(lng_cancel))
, _confirmStyle(st::defaultBoxButton) , _confirmStyle(st::defaultBoxButton)
@ -61,7 +61,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
init(text); init(text);
} }
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback) ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(confirmText) : _confirmText(confirmText)
, _cancelText(lang(lng_cancel)) , _cancelText(lang(lng_cancel))
, _confirmStyle(confirmStyle) , _confirmStyle(confirmStyle)
@ -71,7 +71,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
init(text); init(text);
} }
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const QString &cancelText, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback) ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const QString &cancelText, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(confirmText) : _confirmText(confirmText)
, _cancelText(cancelText) , _cancelText(cancelText)
, _confirmStyle(st::defaultBoxButton) , _confirmStyle(st::defaultBoxButton)
@ -81,7 +81,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
init(text); init(text);
} }
ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, const QString &cancelText, base::lambda<void()> &&confirmedCallback, base::lambda<void()> &&cancelledCallback) ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, const QString &cancelText, base::lambda<void()> confirmedCallback, base::lambda<void()> cancelledCallback)
: _confirmText(confirmText) : _confirmText(confirmText)
, _cancelText(cancelText) , _cancelText(cancelText)
, _confirmStyle(st::defaultBoxButton) , _confirmStyle(st::defaultBoxButton)
@ -91,7 +91,7 @@ ConfirmBox::ConfirmBox(QWidget*, const QString &text, const QString &confirmText
init(text); init(text);
} }
ConfirmBox::ConfirmBox(const InformBoxTag &, const QString &text, const QString &doneText, base::lambda_copy<void()> &&closedCallback) ConfirmBox::ConfirmBox(const InformBoxTag &, const QString &text, const QString &doneText, base::lambda<void()> closedCallback)
: _confirmText(doneText) : _confirmText(doneText)
, _confirmStyle(st::defaultBoxButton) , _confirmStyle(st::defaultBoxButton)
, _informative(true) , _informative(true)
@ -101,7 +101,7 @@ ConfirmBox::ConfirmBox(const InformBoxTag &, const QString &text, const QString
init(text); init(text);
} }
base::lambda<void()> ConfirmBox::generateInformCallback(const base::lambda_copy<void()> &closedCallback) { base::lambda<void()> ConfirmBox::generateInformCallback(base::lambda<void()> closedCallback) {
auto callback = closedCallback; auto callback = closedCallback;
return base::lambda_guarded(this, [this, callback] { return base::lambda_guarded(this, [this, callback] {
closeBox(); closeBox();
@ -212,10 +212,10 @@ void ConfirmBox::paintEvent(QPaintEvent *e) {
_text.drawLeftElided(p, st::boxPadding.left(), st::boxPadding.top(), _textWidth, width(), 16, style::al_left); _text.drawLeftElided(p, st::boxPadding.left(), st::boxPadding.top(), _textWidth, width(), 16, style::al_left);
} }
InformBox::InformBox(QWidget*, const QString &text, base::lambda_copy<void()> &&closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, lang(lng_box_ok), std::move(closedCallback)) { InformBox::InformBox(QWidget*, const QString &text, base::lambda<void()> closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, lang(lng_box_ok), std::move(closedCallback)) {
} }
InformBox::InformBox(QWidget*, const QString &text, const QString &doneText, base::lambda_copy<void()> &&closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, doneText, std::move(closedCallback)) { InformBox::InformBox(QWidget*, const QString &text, const QString &doneText, base::lambda<void()> closedCallback) : ConfirmBox(ConfirmBox::InformBoxTag(), text, doneText, std::move(closedCallback)) {
} }
MaxInviteBox::MaxInviteBox(QWidget*, const QString &link) MaxInviteBox::MaxInviteBox(QWidget*, const QString &link)

18
Telegram/SourceFiles/boxes/confirmbox.h
View file

@ -30,11 +30,11 @@ class FlatLabel;
class InformBox; class InformBox;
class ConfirmBox : public BoxContent, public ClickHandlerHost { class ConfirmBox : public BoxContent, public ClickHandlerHost {
public: public:
ConfirmBox(QWidget*, const QString &text, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>()); ConfirmBox(QWidget*, const QString &text, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>()); ConfirmBox(QWidget*, const QString &text, const QString &confirmText, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>()); ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const QString &cancelText, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>()); ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const QString &cancelText, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, const QString &cancelText, base::lambda<void()> &&confirmedCallback = base::lambda<void()>(), base::lambda<void()> &&cancelledCallback = base::lambda<void()>()); ConfirmBox(QWidget*, const QString &text, const QString &confirmText, const style::RoundButton &confirmStyle, const QString &cancelText, base::lambda<void()> confirmedCallback = base::lambda<void()>(), base::lambda<void()> cancelledCallback = base::lambda<void()>());
void updateLink(); void updateLink();
@ -62,8 +62,8 @@ protected:
private: private:
struct InformBoxTag { struct InformBoxTag {
}; };
ConfirmBox(const InformBoxTag &, const QString &text, const QString &doneText, base::lambda_copy<void()> &&closedCallback); ConfirmBox(const InformBoxTag &, const QString &text, const QString &doneText, base::lambda<void()> closedCallback);
base::lambda<void()> generateInformCallback(const base::lambda_copy<void()> &closedCallback); base::lambda<void()> generateInformCallback(base::lambda<void()> closedCallback);
friend class InformBox; friend class InformBox;
void confirmed(); void confirmed();
@ -93,8 +93,8 @@ private:
class InformBox : public ConfirmBox { class InformBox : public ConfirmBox {
public: public:
InformBox(QWidget*, const QString &text, base::lambda_copy<void()> &&closedCallback = base::lambda_copy<void()>()); InformBox(QWidget*, const QString &text, base::lambda<void()> closedCallback = base::lambda<void()>());
InformBox(QWidget*, const QString &text, const QString &doneText, base::lambda_copy<void()> &&closedCallback = base::lambda_copy<void()>()); InformBox(QWidget*, const QString &text, const QString &doneText, base::lambda<void()> closedCallback = base::lambda<void()>());
}; };

4
Telegram/SourceFiles/boxes/contactsbox.cpp
View file

@ -528,7 +528,7 @@ bool ContactsBox::creationFail(const RPCError &error) {
ContactsBox::Inner::ContactData::ContactData() = default; ContactsBox::Inner::ContactData::ContactData() = default;
ContactsBox::Inner::ContactData::ContactData(PeerData *peer, const base::lambda_copy<void()> &updateCallback) ContactsBox::Inner::ContactData::ContactData(PeerData *peer, base::lambda<void()> updateCallback)
: checkbox(std::make_unique<Ui::RoundImageCheckbox>(st::contactsPhotoCheckbox, updateCallback, PaintUserpicCallback(peer))) { : checkbox(std::make_unique<Ui::RoundImageCheckbox>(st::contactsPhotoCheckbox, updateCallback, PaintUserpicCallback(peer))) {
} }
@ -1471,7 +1471,7 @@ void ContactsBox::Inner::peerUnselected(PeerData *peer) {
changePeerCheckState(data, peer, false, ChangeStateWay::SkipCallback); changePeerCheckState(data, peer, false, ChangeStateWay::SkipCallback);
} }
void ContactsBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback) { void ContactsBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> callback) {
_peerSelectedChangedCallback = std::move(callback); _peerSelectedChangedCallback = std::move(callback);
} }

6
Telegram/SourceFiles/boxes/contactsbox.h
View file

@ -152,7 +152,7 @@ public:
Inner(QWidget *parent, ChatData *chat, MembersFilter membersFilter); Inner(QWidget *parent, ChatData *chat, MembersFilter membersFilter);
Inner(QWidget *parent, UserData *bot); Inner(QWidget *parent, UserData *bot);
void setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback); void setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> callback);
void peerUnselected(PeerData *peer); void peerUnselected(PeerData *peer);
void updateFilter(QString filter = QString()); void updateFilter(QString filter = QString());
@ -164,7 +164,7 @@ public:
QVector<UserData*> selected(); QVector<UserData*> selected();
QVector<MTPInputUser> selectedInputs(); QVector<MTPInputUser> selectedInputs();
bool allAdmins() const; bool allAdmins() const;
void setAllAdminsChangedCallback(base::lambda<void()> &&allAdminsChangedCallback) { void setAllAdminsChangedCallback(base::lambda<void()> allAdminsChangedCallback) {
_allAdminsChangedCallback = std::move(allAdminsChangedCallback); _allAdminsChangedCallback = std::move(allAdminsChangedCallback);
} }
@ -218,7 +218,7 @@ protected:
private: private:
struct ContactData { struct ContactData {
ContactData(); ContactData();
ContactData(PeerData *peer, const base::lambda_copy<void()> &updateCallback); ContactData(PeerData *peer, base::lambda<void()> updateCallback);
~ContactData(); ~ContactData();
std::unique_ptr<Ui::RoundImageCheckbox> checkbox; std::unique_ptr<Ui::RoundImageCheckbox> checkbox;

4
Telegram/SourceFiles/boxes/editcolorbox.h
View file

@ -28,11 +28,11 @@ class EditColorBox : public BoxContent {
public: public:
EditColorBox(QWidget*, const QString &title, QColor current = QColor(255, 255, 255)); EditColorBox(QWidget*, const QString &title, QColor current = QColor(255, 255, 255));
void setSaveCallback(base::lambda<void(QColor)> &&callback) { void setSaveCallback(base::lambda<void(QColor)> callback) {
_saveCallback = std::move(callback); _saveCallback = std::move(callback);
} }
void setCancelCallback(base::lambda<void()> &&callback) { void setCancelCallback(base::lambda<void()> callback) {
_cancelCallback = std::move(callback); _cancelCallback = std::move(callback);
} }

4
Telegram/SourceFiles/boxes/send_files_box.h
View file

@ -37,10 +37,10 @@ public:
SendFilesBox(QWidget*, const QStringList &files, CompressConfirm compressed); SendFilesBox(QWidget*, const QStringList &files, CompressConfirm compressed);
SendFilesBox(QWidget*, const QString &phone, const QString &firstname, const QString &lastname); SendFilesBox(QWidget*, const QString &phone, const QString &firstname, const QString &lastname);
void setConfirmedCallback(base::lambda<void(const QStringList &files, bool compressed, const QString &caption, bool ctrlShiftEnter)> &&callback) { void setConfirmedCallback(base::lambda<void(const QStringList &files, bool compressed, const QString &caption, bool ctrlShiftEnter)> callback) {
_confirmedCallback = std::move(callback); _confirmedCallback = std::move(callback);
} }
void setCancelledCallback(base::lambda<void()> &&callback) { void setCancelledCallback(base::lambda<void()> callback) {
_cancelledCallback = std::move(callback); _cancelledCallback = std::move(callback);
} }

4
Telegram/SourceFiles/boxes/sharebox.cpp
View file

@ -513,7 +513,7 @@ void ShareBox::Inner::paintChat(Painter &p, TimeMs ms, Chat *chat, int index) {
chat->name.drawLeftElided(p, x + nameLeft, y + nameTop, nameWidth, outerWidth, 2, style::al_top, 0, -1, 0, true); chat->name.drawLeftElided(p, x + nameLeft, y + nameTop, nameWidth, outerWidth, 2, style::al_top, 0, -1, 0, true);
} }
ShareBox::Inner::Chat::Chat(PeerData *peer, const base::lambda_copy<void()> &updateCallback) ShareBox::Inner::Chat::Chat(PeerData *peer, base::lambda<void()> updateCallback)
: peer(peer) : peer(peer)
, checkbox(st::sharePhotoCheckbox, updateCallback, PaintUserpicCallback(peer)) , checkbox(st::sharePhotoCheckbox, updateCallback, PaintUserpicCallback(peer))
, name(st::sharePhotoCheckbox.imageRadius * 2) { , name(st::sharePhotoCheckbox.imageRadius * 2) {
@ -649,7 +649,7 @@ void ShareBox::Inner::peerUnselected(PeerData *peer) {
changePeerCheckState(chat, false, ChangeStateWay::SkipCallback); changePeerCheckState(chat, false, ChangeStateWay::SkipCallback);
} }
void ShareBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback) { void ShareBox::Inner::setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> callback) {
_peerSelectedChangedCallback = std::move(callback); _peerSelectedChangedCallback = std::move(callback);
} }

4
Telegram/SourceFiles/boxes/sharebox.h
View file

@ -114,7 +114,7 @@ class ShareBox::Inner : public TWidget, public RPCSender, private base::Subscrib
public: public:
Inner(QWidget *parent, ShareBox::FilterCallback &&filterCallback); Inner(QWidget *parent, ShareBox::FilterCallback &&filterCallback);
void setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> &&callback); void setPeerSelectedChangedCallback(base::lambda<void(PeerData *peer, bool selected)> callback);
void peerUnselected(PeerData *peer); void peerUnselected(PeerData *peer);
QVector<PeerData*> selected() const; QVector<PeerData*> selected() const;
@ -153,7 +153,7 @@ private:
int displayedChatsCount() const; int displayedChatsCount() const;
struct Chat { struct Chat {
Chat(PeerData *peer, const base::lambda_copy<void()> &updateCallback); Chat(PeerData *peer, base::lambda<void()> updateCallback);
PeerData *peer; PeerData *peer;
Ui::RoundImageCheckbox checkbox; Ui::RoundImageCheckbox checkbox;

4
Telegram/SourceFiles/boxes/stickers_box.h
View file

@ -163,10 +163,10 @@ public:
void setFullOrder(const Stickers::Order &order); void setFullOrder(const Stickers::Order &order);
void setRemovedSets(const Stickers::Order &removed); void setRemovedSets(const Stickers::Order &removed);
void setInstallSetCallback(base::lambda<void(uint64 setId)> &&callback) { void setInstallSetCallback(base::lambda<void(uint64 setId)> callback) {
_installSetCallback = std::move(callback); _installSetCallback = std::move(callback);
} }
void setLoadMoreCallback(base::lambda<void()> &&callback) { void setLoadMoreCallback(base::lambda<void()> callback) {
_loadMoreCallback = std::move(callback); _loadMoreCallback = std::move(callback);
} }

2
Telegram/SourceFiles/core/click_handler.h
View file

@ -180,7 +180,7 @@ protected:
class LambdaClickHandler : public ClickHandler { class LambdaClickHandler : public ClickHandler {
public: public:
LambdaClickHandler(base::lambda<void()> &&handler) : _handler(std::move(handler)) { LambdaClickHandler(base::lambda<void()> handler) : _handler(std::move(handler)) {
} }
void onClick(Qt::MouseButton button) const override final { void onClick(Qt::MouseButton button) const override final {
if (button == Qt::LeftButton && _handler) { if (button == Qt::LeftButton && _handler) {

856
Telegram/SourceFiles/core/lambda.h
View file

@ -23,415 +23,454 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
#include <memory> #include <memory>
namespace base { namespace base {
namespace internal {
template <typename Return, typename ...Args>
struct lambda_wrap_helper_base {
using construct_copy_other_type = void(*)(void *, const void *); // dst, src
using construct_move_other_type = void(*)(void *, void *); // dst, src
using call_type = Return(*)(const void *, Args...);
using destruct_type = void(*)(const void *);
lambda_wrap_helper_base() = delete;
lambda_wrap_helper_base(const lambda_wrap_helper_base &other) = delete;
lambda_wrap_helper_base &operator=(const lambda_wrap_helper_base &other) = delete;
lambda_wrap_helper_base(
construct_copy_other_type construct_copy_other,
construct_move_other_type construct_move_other,
call_type call,
destruct_type destruct)
: construct_copy_other(construct_copy_other)
, construct_move_other(construct_move_other)
, call(call)
, destruct(destruct) {
}
const construct_copy_other_type construct_copy_other;
const construct_move_other_type construct_move_other;
const call_type call;
const destruct_type destruct;
static constexpr size_t kFullStorageSize = 24U + sizeof(void*);
static constexpr size_t kStorageSize = kFullStorageSize - sizeof(void*);
using alignment = uint64;
template <typename Lambda>
using IsLarge = std::integral_constant<bool, !(sizeof(std::decay_t<Lambda>) <= kStorageSize)>;
protected:
static void bad_construct_copy(void *lambda, const void *source) {
t_assert(!"base::lambda bad_construct_copy() called!");
}
};
template <typename Return, typename ...Args>
struct lambda_wrap_empty : public lambda_wrap_helper_base<Return, Args...> {
static void construct_copy_other_method(void *lambda, const void *source) {
}
static void construct_move_other_method(void *lambda, void *source) {
}
static Return call_method(const void *lambda, Args... args) {
t_assert(!"base::lambda empty call_method() called!");
return Return();
}
static void destruct_method(const void *lambda) {
}
lambda_wrap_empty() : lambda_wrap_helper_base<Return, Args...>(
&lambda_wrap_empty::construct_copy_other_method,
&lambda_wrap_empty::construct_move_other_method,
&lambda_wrap_empty::call_method,
&lambda_wrap_empty::destruct_method) {
}
static const lambda_wrap_empty<Return, Args...> instance;
};
template <typename Return, typename ...Args>
const lambda_wrap_empty<Return, Args...> lambda_wrap_empty<Return, Args...>::instance = {};
template <typename Lambda, typename IsLarge, typename Return, typename ...Args> struct lambda_wrap_helper_move_impl;
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_move_impl<Lambda, std::true_type, Return, Args...> : public lambda_wrap_helper_base<Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using LambdaPtr = std::unique_ptr<JustLambda>;
using Parent = lambda_wrap_helper_base<Return, Args...>;
static void construct_move_other_method(void *lambda, void *source) {
auto source_lambda = static_cast<LambdaPtr*>(source);
new (lambda) LambdaPtr(std::move(*source_lambda));
}
static void construct_move_lambda_method(void *lambda, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (lambda) LambdaPtr(std::make_unique<JustLambda>(static_cast<JustLambda&&>(*source_lambda)));
}
static Return call_method(const void *lambda, Args... args) {
return (**static_cast<const LambdaPtr*>(lambda))(std::forward<Args>(args)...);
}
static void destruct_method(const void *lambda) {
static_cast<const LambdaPtr*>(lambda)->~LambdaPtr();
}
lambda_wrap_helper_move_impl() : Parent(
&Parent::bad_construct_copy,
&lambda_wrap_helper_move_impl::construct_move_other_method,
&lambda_wrap_helper_move_impl::call_method,
&lambda_wrap_helper_move_impl::destruct_method) {
}
protected:
lambda_wrap_helper_move_impl(
typename Parent::construct_copy_other_type construct_copy_other
) : Parent(
construct_copy_other,
&lambda_wrap_helper_move_impl::construct_move_other_method,
&lambda_wrap_helper_move_impl::call_method,
&lambda_wrap_helper_move_impl::destruct_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_move_impl<Lambda, std::false_type, Return, Args...> : public lambda_wrap_helper_base<Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using Parent = lambda_wrap_helper_base<Return, Args...>;
static void construct_move_other_method(void *lambda, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (lambda) JustLambda(static_cast<JustLambda&&>(*source_lambda));
}
static void construct_move_lambda_method(void *lambda, void *source) {
static_assert(alignof(JustLambda) <= alignof(typename Parent::alignment), "Bad lambda alignment.");
auto space = sizeof(JustLambda);
auto aligned = std::align(alignof(JustLambda), space, lambda, space);
t_assert(aligned == lambda);
auto source_lambda = static_cast<JustLambda*>(source);
new (lambda) JustLambda(static_cast<JustLambda&&>(*source_lambda));
}
static Return call_method(const void *lambda, Args... args) {
return (*static_cast<const JustLambda*>(lambda))(std::forward<Args>(args)...);
}
static void destruct_method(const void *lambda) {
static_cast<const JustLambda*>(lambda)->~JustLambda();
}
lambda_wrap_helper_move_impl() : Parent(
&Parent::bad_construct_copy,
&lambda_wrap_helper_move_impl::construct_move_other_method,
&lambda_wrap_helper_move_impl::call_method,
&lambda_wrap_helper_move_impl::destruct_method) {
}
protected:
lambda_wrap_helper_move_impl(
typename Parent::construct_copy_other_type construct_copy_other
) : Parent(
construct_copy_other,
&lambda_wrap_helper_move_impl::construct_move_other_method,
&lambda_wrap_helper_move_impl::call_method,
&lambda_wrap_helper_move_impl::destruct_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_move : public lambda_wrap_helper_move_impl<Lambda
, typename lambda_wrap_helper_base<Return, Args...>::template IsLarge<Lambda>
, Return, Args...> {
static const lambda_wrap_helper_move instance;
};
template <typename Lambda, typename Return, typename ...Args>
const lambda_wrap_helper_move<Lambda, Return, Args...> lambda_wrap_helper_move<Lambda, Return, Args...>::instance = {};
template <typename Lambda, typename IsLarge, typename Return, typename ...Args> struct lambda_wrap_helper_copy_impl;
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_copy_impl<Lambda, std::true_type, Return, Args...> : public lambda_wrap_helper_move_impl<Lambda, std::true_type, Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using LambdaPtr = std::unique_ptr<JustLambda>;
using Parent = lambda_wrap_helper_move_impl<Lambda, std::true_type, Return, Args...>;
static void construct_copy_other_method(void *lambda, const void *source) {
auto source_lambda = static_cast<const LambdaPtr*>(source);
new (lambda) LambdaPtr(std::make_unique<JustLambda>(*source_lambda->get()));
}
static void construct_copy_lambda_method(void *lambda, const void *source) {
auto source_lambda = static_cast<const JustLambda*>(source);
new (lambda) LambdaPtr(std::make_unique<JustLambda>(static_cast<const JustLambda &>(*source_lambda)));
}
lambda_wrap_helper_copy_impl() : Parent(&lambda_wrap_helper_copy_impl::construct_copy_other_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_copy_impl<Lambda, std::false_type, Return, Args...> : public lambda_wrap_helper_move_impl<Lambda, std::false_type, Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using Parent = lambda_wrap_helper_move_impl<Lambda, std::false_type, Return, Args...>;
static void construct_copy_other_method(void *lambda, const void *source) {
auto source_lambda = static_cast<const JustLambda*>(source);
new (lambda) JustLambda(static_cast<const JustLambda &>(*source_lambda));
}
static void construct_copy_lambda_method(void *lambda, const void *source) {
static_assert(alignof(JustLambda) <= alignof(typename Parent::alignment), "Bad lambda alignment.");
auto space = sizeof(JustLambda);
auto aligned = std::align(alignof(JustLambda), space, lambda, space);
t_assert(aligned == lambda);
auto source_lambda = static_cast<const JustLambda*>(source);
new (lambda) JustLambda(static_cast<const JustLambda &>(*source_lambda));
}
lambda_wrap_helper_copy_impl() : Parent(&lambda_wrap_helper_copy_impl::construct_copy_other_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct lambda_wrap_helper_copy : public lambda_wrap_helper_copy_impl<Lambda
, typename lambda_wrap_helper_base<Return, Args...>::template IsLarge<Lambda>
, Return, Args...> {
static const lambda_wrap_helper_copy instance;
};
template <typename Lambda, typename Return, typename ...Args>
const lambda_wrap_helper_copy<Lambda, Return, Args...> lambda_wrap_helper_copy<Lambda, Return, Args...>::instance = {};
} // namespace internal
template <typename Function> class lambda_once;
template <typename Function> class lambda; template <typename Function> class lambda;
template <typename Function> class lambda_copy;
template <typename Return, typename ...Args>
class lambda<Return(Args...)> {
using BaseHelper = internal::lambda_wrap_helper_base<Return, Args...>;
using EmptyHelper = internal::lambda_wrap_empty<Return, Args...>;
template <typename Lambda>
using IsUnique = std::is_same<lambda, std::decay_t<Lambda>>;
template <typename Lambda>
using IsWrap = std::is_same<lambda_copy<Return(Args...)>, std::decay_t<Lambda>>;
template <typename Lambda>
using IsOther = std::enable_if_t<!IsUnique<Lambda>::value && !IsWrap<Lambda>::value>;
template <typename Lambda>
using IsRvalue = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>;
public:
using return_type = Return;
lambda() : helper_(&EmptyHelper::instance) {
}
lambda(const lambda &other) = delete;
lambda &operator=(const lambda &other) = delete;
lambda(lambda &&other) : helper_(other.helper_) {
helper_->construct_move_other(storage_, other.storage_);
}
lambda &operator=(lambda &&other) {
auto temp = std::move(other);
helper_->destruct(storage_);
helper_ = temp.helper_;
helper_->construct_move_other(storage_, temp.storage_);
return *this;
}
void swap(lambda &other) {
if (this != &other) std::swap(*this, other);
}
template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
lambda(Lambda &&other) : helper_(&internal::lambda_wrap_helper_move<Lambda, Return, Args...>::instance) {
internal::lambda_wrap_helper_move<Lambda, Return, Args...>::construct_move_lambda_method(storage_, &other);
}
template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
lambda &operator=(Lambda &&other) {
auto temp = std::move(other);
helper_->destruct(storage_);
helper_ = &internal::lambda_wrap_helper_move<Lambda, Return, Args...>::instance;
internal::lambda_wrap_helper_move<Lambda, Return, Args...>::construct_move_lambda_method(storage_, &temp);
return *this;
}
inline Return operator()(Args... args) const {
return helper_->call(storage_, std::forward<Args>(args)...);
}
explicit operator bool() const {
return (helper_ != &EmptyHelper::instance);
}
~lambda() {
helper_->destruct(storage_);
}
protected:
struct Private {
};
lambda(const BaseHelper *helper, const Private &) : helper_(helper) {
}
using alignment = typename BaseHelper::alignment;
static_assert(BaseHelper::kStorageSize % sizeof(alignment) == 0, "Bad storage size.");
alignas(typename BaseHelper::alignment) alignment storage_[BaseHelper::kStorageSize / sizeof(alignment)];
const BaseHelper *helper_;
};
template <typename Return, typename ...Args>
class lambda_copy<Return(Args...)> : public lambda<Return(Args...)> {
using BaseHelper = internal::lambda_wrap_helper_base<Return, Args...>;
using Parent = lambda<Return(Args...)>;
template <typename Lambda>
using IsOther = std::enable_if_t<!std::is_same<lambda_copy, std::decay_t<Lambda>>::value>;
template <typename Lambda>
using IsRvalue = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>;
template <typename Lambda>
using IsNotRvalue = std::enable_if_t<!std::is_rvalue_reference<Lambda&&>::value>;
public:
lambda_copy() = default;
lambda_copy(const lambda_copy &other) : Parent(other.helper_, typename Parent::Private()) {
this->helper_->construct_copy_other(this->storage_, other.storage_);
}
lambda_copy &operator=(const lambda_copy &other) {
auto temp = other;
temp.swap(*this);
return *this;
}
lambda_copy(lambda_copy &&other) = default;
lambda_copy &operator=(lambda_copy &&other) = default;
void swap(lambda_copy &other) {
if (this != &other) std::swap(*this, other);
}
lambda_copy clone() const {
return *this;
}
template <typename Lambda, typename = IsOther<Lambda>>
lambda_copy(const Lambda &other) : Parent(&internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::instance, typename Parent::Private()) {
internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::construct_copy_lambda_method(this->storage_, &other);
}
template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
lambda_copy(Lambda &&other) : Parent(&internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::instance, typename Parent::Private()) {
internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::construct_move_lambda_method(this->storage_, &other);
}
template <typename Lambda, typename = IsOther<Lambda>>
lambda_copy &operator=(const Lambda &other) {
auto temp = other;
this->helper_->destruct(this->storage_);
this->helper_ = &internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::instance;
internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::construct_copy_lambda_method(this->storage_, &other);
return *this;
}
template <typename Lambda, typename = IsOther<Lambda>, typename = IsRvalue<Lambda>>
lambda_copy &operator=(Lambda &&other) {
auto temp = std::move(other);
this->helper_->destruct(this->storage_);
this->helper_ = &internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::instance;
internal::lambda_wrap_helper_copy<Lambda, Return, Args...>::construct_move_lambda_method(this->storage_, &other);
return *this;
}
};
// Get lambda type from a lambda template parameter. // Get lambda type from a lambda template parameter.
namespace internal { namespace lambda_internal {
template <typename FunctionType> template <typename FunctionType>
struct lambda_type_resolver; struct type_resolver;
template <typename Lambda, typename R, typename ...Args> template <typename Lambda, typename R, typename ...Args>
struct lambda_type_resolver<R(Lambda::*)(Args...) const> { struct type_resolver<R(Lambda::*)(Args...) const> {
using type = lambda<R(Args...)>; using type = lambda<R(Args...)>;
static constexpr auto is_mutable = false; static constexpr auto is_mutable = false;
}; };
template <typename Lambda, typename R, typename ...Args> template <typename Lambda, typename R, typename ...Args>
struct lambda_type_resolver<R(Lambda::*)(Args...)> { struct type_resolver<R(Lambda::*)(Args...)> {
using type = lambda<R(Args...)>; using type = lambda<R(Args...)>;
static constexpr auto is_mutable = true; static constexpr auto is_mutable = true;
}; };
template <typename FunctionType> template <typename Lambda>
struct lambda_type_helper { struct type_helper {
using type = typename lambda_type_resolver<decltype(&FunctionType::operator())>::type; using type = typename type_resolver<decltype(&Lambda::operator())>::type;
static constexpr auto is_mutable = type_resolver<decltype(&Lambda::operator())>::is_mutable;
}; };
} // namespace internal } // namespace lambda_internal
template <typename FunctionType> template <typename Lambda>
using lambda_type = typename internal::lambda_type_helper<FunctionType>::type; using lambda_type = typename lambda_internal::type_helper<std::decay_t<Lambda>>::type;
template <typename Lambda>
constexpr bool lambda_is_mutable = lambda_internal::type_helper<std::decay_t<Lambda>>::is_mutable;
namespace lambda_internal {
constexpr auto kFullStorageSize = 32U;
static_assert(kFullStorageSize % sizeof(void*) == 0, "Invalid pointer size!");
constexpr auto kStorageSize = kFullStorageSize - sizeof(void*);
using alignment = std::max_align_t;
template <typename Lambda>
constexpr bool is_large = (sizeof(std::decay_t<Lambda>) > kStorageSize);
inline void bad_construct_copy(void *lambda, const void *source) {
t_assert(!"base::lambda bad_construct_copy() called!");
}
template <typename Return, typename ...Args>
Return bad_const_call(const void *lambda, Args...) {
t_assert(!"base::lambda bad_const_call() called!");
return Return();
}
template <typename Return, typename ...Args>
struct vtable_base {
using construct_copy_other_type = void(*)(void *, const void *); // dst, src
using construct_move_other_type = void(*)(void *, void *); // dst, src
using const_call_type = Return(*)(const void *, Args...);
using call_type = Return(*)(void *, Args...);
using destruct_type = void(*)(const void *);
vtable_base() = delete;
vtable_base(const vtable_base &other) = delete;
vtable_base &operator=(const vtable_base &other) = delete;
vtable_base(
construct_copy_other_type construct_copy_other,
construct_move_other_type construct_move_other,
const_call_type const_call,
call_type call,
destruct_type destruct)
: construct_copy_other(construct_copy_other)
, construct_move_other(construct_move_other)
, const_call(const_call)
, call(call)
, destruct(destruct) {
}
const construct_copy_other_type construct_copy_other;
const construct_move_other_type construct_move_other;
const const_call_type const_call;
const call_type call;
const destruct_type destruct;
};
template <typename Lambda, bool IsLarge, typename Return, typename ...Args> struct vtable_once_impl;
template <typename Lambda, typename Return, typename ...Args>
struct vtable_once_impl<Lambda, true, Return, Args...> : public vtable_base<Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using LambdaPtr = std::unique_ptr<JustLambda>;
using Parent = vtable_base<Return, Args...>;
static void construct_move_other_method(void *storage, void *source) {
auto source_lambda_ptr = static_cast<LambdaPtr*>(source);
new (storage) LambdaPtr(std::move(*source_lambda_ptr));
}
static Return call_method(void *storage, Args... args) {
return (**static_cast<LambdaPtr*>(storage))(std::forward<Args>(args)...);
}
static void destruct_method(const void *storage) {
static_cast<const LambdaPtr*>(storage)->~LambdaPtr();
}
vtable_once_impl() : Parent(
&bad_construct_copy,
&vtable_once_impl::construct_move_other_method,
&bad_const_call<Return, Args...>,
&vtable_once_impl::call_method,
&vtable_once_impl::destruct_method) {
}
// Used directly.
static void construct_move_lambda_method(void *storage, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (storage) LambdaPtr(std::make_unique<JustLambda>(static_cast<JustLambda&&>(*source_lambda)));
}
protected:
vtable_once_impl(
typename Parent::construct_copy_other_type construct_copy_other,
typename Parent::const_call_type const_call
) : Parent(
construct_copy_other,
&vtable_once_impl::construct_move_other_method,
const_call,
&vtable_once_impl::call_method,
&vtable_once_impl::destruct_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct vtable_once_impl<Lambda, false, Return, Args...> : public vtable_base<Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using Parent = vtable_base<Return, Args...>;
static void construct_move_other_method(void *storage, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (storage) JustLambda(static_cast<JustLambda&&>(*source_lambda));
}
static Return call_method(void *storage, Args... args) {
return (*static_cast<JustLambda*>(storage))(std::forward<Args>(args)...);
}
static void destruct_method(const void *storage) {
static_cast<const JustLambda*>(storage)->~JustLambda();
}
vtable_once_impl() : Parent(
&bad_construct_copy,
&vtable_once_impl::construct_move_other_method,
&bad_const_call<Args...>,
&vtable_once_impl::call_method,
&vtable_once_impl::destruct_method) {
}
// Used directly.
static void construct_move_lambda_method(void *storage, void *source) {
auto source_lambda = static_cast<JustLambda*>(source);
new (storage) JustLambda(static_cast<JustLambda&&>(*source_lambda));
}
protected:
vtable_once_impl(
typename Parent::construct_copy_other_type construct_copy_other,
typename Parent::const_call_type const_call
) : Parent(
construct_copy_other,
&vtable_once_impl::construct_move_other_method,
const_call,
&vtable_once_impl::call_method,
&vtable_once_impl::destruct_method) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct vtable_once : public vtable_once_impl<Lambda, is_large<Lambda>, Return, Args...> {
static const vtable_once instance;
};
template <typename Lambda, typename Return, typename ...Args>
const vtable_once<Lambda, Return, Args...> vtable_once<Lambda, Return, Args...>::instance = {};
template <typename Lambda, bool IsLarge, typename Return, typename ...Args> struct vtable_impl;
template <typename Lambda, typename Return, typename ...Args>
struct vtable_impl<Lambda, true, Return, Args...> : public vtable_once_impl<Lambda, true, Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using LambdaPtr = std::unique_ptr<JustLambda>;
using Parent = vtable_once_impl<Lambda, true, Return, Args...>;
static void construct_copy_other_method(void *storage, const void *source) {
auto source_lambda = static_cast<const LambdaPtr*>(source);
new (storage) LambdaPtr(std::make_unique<JustLambda>(*source_lambda->get()));
}
static Return const_call_method(const void *storage, Args... args) {
auto lambda_ptr = static_cast<const LambdaPtr*>(storage)->get();
return (*static_cast<const JustLambda*>(lambda_ptr))(std::forward<Args>(args)...);
}
vtable_impl() : Parent(
&vtable_impl::construct_copy_other_method,
&vtable_impl::const_call_method
) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct vtable_impl<Lambda, false, Return, Args...> : public vtable_once_impl<Lambda, false, Return, Args...> {
using JustLambda = std::decay_t<Lambda>;
using Parent = vtable_once_impl<Lambda, false, Return, Args...>;
static void construct_copy_other_method(void *storage, const void *source) {
auto source_lambda = static_cast<const JustLambda*>(source);
new (storage) JustLambda(static_cast<const JustLambda &>(*source_lambda));
}
static Return const_call_method(const void *storage, Args... args) {
static_assert(!lambda_is_mutable<JustLambda>, "For mutable lambda use base::lambda_once wrapper");
return (*static_cast<const JustLambda*>(storage))(std::forward<Args>(args)...);
}
vtable_impl() : Parent(
&vtable_impl::construct_copy_other_method,
&vtable_impl::const_call_method
) {
}
};
template <typename Lambda, typename Return, typename ...Args>
struct vtable : public vtable_impl<Lambda, is_large<Lambda>, Return, Args...> {
static const vtable instance;
};
template <typename Lambda, typename Return, typename ...Args>
const vtable<Lambda, Return, Args...> vtable<Lambda, Return, Args...>::instance = {};
} // namespace lambda_internal
template <typename Return, typename ...Args>
class lambda_once<Return(Args...)> {
using VTable = lambda_internal::vtable_base<Return, Args...>;
public:
using return_type = Return;
lambda_once() {
data_.vtable = nullptr;
}
lambda_once(const lambda_once &other) = delete;
lambda_once &operator=(const lambda_once &other) = delete;
// Move construct / assign from the same type.
lambda_once(lambda_once &&other) {
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_move_other(data_.storage, other.data_.storage);
}
}
lambda_once &operator=(lambda_once &&other) {
if (this != &other) {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_move_other(data_.storage, other.data_.storage);
data_.vtable->destruct(other.data_.storage);
other.data_.vtable = nullptr;
}
}
return *this;
}
// Move construct / assign from a derived type.
lambda_once(lambda<Return(Args...)> &&other) {
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_move_other(data_.storage, other.data_.storage);
data_.vtable->destruct(other.data_.storage);
other.data_.vtable = nullptr;
}
}
lambda_once &operator=(lambda<Return(Args...)> &&other) {
if (this != &other) {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_move_other(data_.storage, other.data_.storage);
data_.vtable->destruct(other.data_.storage);
other.data_.vtable = nullptr;
}
}
return *this;
}
// Copy construct / assign from a derived type.
lambda_once(const lambda<Return(Args...)> &other) {
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_copy_other(data_.storage, other.data_.storage);
}
}
lambda_once &operator=(const lambda<Return(Args...)> &other) {
if (this != &other) {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
if ((data_.vtable = other.data_.vtable)) {
data_.vtable->construct_copy_other(data_.storage, other.data_.storage);
}
}
return *this;
}
// Copy / move construct / assign from an arbitrary type.
template <typename Lambda>
lambda_once(Lambda other) {
data_.vtable = &lambda_internal::vtable_once<Lambda, Return, Args...>::instance;
lambda_internal::vtable_once<Lambda, Return, Args...>::construct_move_lambda_method(data_.storage, &other);
}
template <typename Lambda>
lambda_once &operator=(Lambda other) {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
data_.vtable = &lambda_internal::vtable_once<Lambda, Return, Args...>::instance;
lambda_internal::vtable_once<Lambda, Return, Args...>::construct_move_lambda_method(data_.storage, &other);
return *this;
}
void swap(lambda_once &other) {
if (this != &other) {
std::swap(*this, other);
}
}
inline Return operator()(Args... args) {
t_assert(data_.vtable != nullptr);
return data_.vtable->call(data_.storage, std::forward<Args>(args)...);
}
explicit operator bool() const {
return (data_.vtable != nullptr);
}
~lambda_once() {
if (data_.vtable) {
data_.vtable->destruct(data_.storage);
}
}
protected:
struct Private {
};
lambda_once(const VTable *vtable, const Private &) {
data_.vtable = vtable;
}
struct Data {
char storage[lambda_internal::kStorageSize];
const VTable *vtable;
};
union {
lambda_internal::alignment alignment_;
char raw_[lambda_internal::kFullStorageSize];
Data data_;
};
};
template <typename Return, typename ...Args>
class lambda<Return(Args...)> final : public lambda_once<Return(Args...)> {
using Parent = lambda_once<Return(Args...)>;
public:
lambda() = default;
// Move construct / assign from the same type.
lambda(lambda<Return(Args...)> &&other) : Parent(std::move(other)) {
}
lambda &operator=(lambda<Return(Args...)> &&other) {
Parent::operator=(std::move(other));
return *this;
}
// Copy construct / assign from the same type.
lambda(const lambda<Return(Args...)> &other) : Parent(other) {
}
lambda &operator=(const lambda<Return(Args...)> &other) {
Parent::operator=(other);
return *this;
}
// Copy / move construct / assign from an arbitrary type.
template <typename Lambda>
lambda(Lambda other) : Parent(&lambda_internal::vtable<Lambda, Return, Args...>::instance, typename Parent::Private()) {
lambda_internal::vtable<Lambda, Return, Args...>::construct_move_lambda_method(this->data_.storage, &other);
}
template <typename Lambda>
lambda &operator=(Lambda other) {
if (this->data_.vtable) {
this->data_.vtable->destruct(this->data_.storage);
}
this->data_.vtable = &lambda_internal::vtable<Lambda, Return, Args...>::instance;
lambda_internal::vtable<Lambda, Return, Args...>::construct_move_lambda_method(this->data_.storage, &other);
return *this;
}
inline Return operator()(Args... args) const {
t_assert(this->data_.vtable != nullptr);
return this->data_.vtable->const_call(this->data_.storage, std::forward<Args>(args)...);
}
void swap(lambda &other) {
if (this != &other) {
std::swap(*this, other);
}
}
};
// Guard lambda call by one or many QObject* weak pointers. // Guard lambda call by one or many QObject* weak pointers.
namespace internal { namespace lambda_internal {
template <int N>
class lambda_guard_creator;
template <int N, typename Lambda> template <int N, typename Lambda>
class lambda_guard_data { class guard_data {
public: public:
using return_type = typename lambda_type<Lambda>::return_type; using return_type = typename lambda_type<Lambda>::return_type;
template <typename ...PointersAndLambda> template <typename ...PointersAndLambda>
inline lambda_guard_data(PointersAndLambda&&... qobjectsAndLambda) : _lambda(init(_pointers, std::forward<PointersAndLambda>(qobjectsAndLambda)...)) { inline guard_data(PointersAndLambda&&... qobjectsAndLambda) : _lambda(init(_pointers, std::forward<PointersAndLambda>(qobjectsAndLambda)...)) {
} }
inline lambda_guard_data(const lambda_guard_data &other) : _lambda(other._lambda) { inline guard_data(const guard_data &other) : _lambda(other._lambda) {
for (auto i = 0; i != N; ++i) { for (auto i = 0; i != N; ++i) {
_pointers[i] = other._pointers[i]; _pointers[i] = other._pointers[i];
} }
} }
template <typename ...Args>
inline return_type operator()(Args&&... args) {
for (int i = 0; i != N; ++i) {
if (!_pointers[i]) {
return return_type();
}
}
return _lambda(std::forward<Args>(args)...);
}
template <typename ...Args> template <typename ...Args>
inline return_type operator()(Args&&... args) const { inline return_type operator()(Args&&... args) const {
for (int i = 0; i != N; ++i) { for (int i = 0; i != N; ++i) {
@ -458,31 +497,36 @@ private:
}; };
template <int N, typename Lambda> template <int N, typename Lambda>
class lambda_guard { class guard {
public: public:
using return_type = typename lambda_type<Lambda>::return_type; using return_type = typename lambda_type<Lambda>::return_type;
template <typename ...PointersAndLambda> template <typename ...PointersAndLambda>
inline lambda_guard(PointersAndLambda&&... qobjectsAndLambda) : _data(std::make_unique<lambda_guard_data<N, Lambda>>(std::forward<PointersAndLambda>(qobjectsAndLambda)...)) { inline guard(PointersAndLambda&&... qobjectsAndLambda) : _data(std::make_unique<guard_data<N, Lambda>>(std::forward<PointersAndLambda>(qobjectsAndLambda)...)) {
static_assert(sizeof...(PointersAndLambda) == N + 1, "Wrong argument count!"); static_assert(sizeof...(PointersAndLambda) == N + 1, "Wrong argument count!");
} }
inline lambda_guard(const lambda_guard &&other) : _data(std::move(other._data)) { inline guard(const guard &other) : _data(std::make_unique<guard_data<N, Lambda>>(static_cast<const guard_data<N, Lambda> &>(*other._data))) {
} }
inline lambda_guard(lambda_guard &&other) : _data(std::move(other._data)) { inline guard(guard &&other) : _data(std::move(other._data)) {
} }
inline lambda_guard &operator=(const lambda_guard &&other) { inline guard &operator=(const guard &&other) {
_data = std::move(other._data); _data = std::move(other._data);
return *this; return *this;
} }
inline lambda_guard &operator=(lambda_guard &&other) { inline guard &operator=(guard &&other) {
_data = std::move(other._data); _data = std::move(other._data);
return *this; return *this;
} }
template <typename ...Args>
inline return_type operator()(Args&&... args) {
return (*_data)(std::forward<Args>(args)...);
}
template <typename ...Args> template <typename ...Args>
inline return_type operator()(Args&&... args) const { inline return_type operator()(Args&&... args) const {
return (*_data)(std::forward<Args>(args)...); return (*_data)(std::forward<Args>(args)...);
@ -492,51 +536,45 @@ public:
return !_data; return !_data;
} }
lambda_guard clone() const {
return lambda_guard(*this);
}
private: private:
inline lambda_guard(const lambda_guard &other) : _data(std::make_unique<lambda_guard_data<N, Lambda>>(static_cast<const lambda_guard_data<N, Lambda> &>(*other._data))) { mutable std::unique_ptr<guard_data<N, Lambda>> _data;
}
mutable std::unique_ptr<lambda_guard_data<N, Lambda>> _data;
}; };
template <int N, int K, typename ...PointersAndLambda> template <int N, int K, typename ...PointersAndLambda>
struct lambda_guard_type; struct guard_type;
template <int N, int K, typename Pointer, typename ...PointersAndLambda> template <int N, int K, typename Pointer, typename ...PointersAndLambda>
struct lambda_guard_type<N, K, Pointer, PointersAndLambda...> { struct guard_type<N, K, Pointer, PointersAndLambda...> {
using type = typename lambda_guard_type<N, K - 1, PointersAndLambda...>::type; using type = typename guard_type<N, K - 1, PointersAndLambda...>::type;
}; };
template <int N, typename Lambda> template <int N, typename Lambda>
struct lambda_guard_type<N, 0, Lambda> { struct guard_type<N, 0, Lambda> {
using type = lambda_guard<N, Lambda>; using type = guard<N, Lambda>;
}; };
template <typename ...PointersAndLambda> template <typename ...PointersAndLambda>
struct lambda_guard_type_helper { struct guard_type_helper {
static constexpr int N = sizeof...(PointersAndLambda); static constexpr int N = sizeof...(PointersAndLambda);
using type = typename lambda_guard_type<N - 1, N - 1, PointersAndLambda...>::type; using type = typename guard_type<N - 1, N - 1, PointersAndLambda...>::type;
}; };
template <typename ...PointersAndLambda> template <typename ...PointersAndLambda>
using lambda_guard_t = typename lambda_guard_type_helper<PointersAndLambda...>::type; using guard_t = typename guard_type_helper<PointersAndLambda...>::type;
template <int N, typename Lambda> template <int N, typename Lambda>
struct lambda_type_helper<lambda_guard<N, Lambda>> { struct type_helper<guard<N, Lambda>> {
using type = typename lambda_type_helper<Lambda>::type; using type = typename type_helper<Lambda>::type;
static constexpr auto is_mutable = type_helper<Lambda>::is_mutable;
}; };
} // namespace internal } // namespace lambda_internal
template <typename ...PointersAndLambda> template <typename ...PointersAndLambda>
inline internal::lambda_guard_t<PointersAndLambda...> lambda_guarded(PointersAndLambda&&... qobjectsAndLambda) { inline lambda_internal::guard_t<PointersAndLambda...> lambda_guarded(PointersAndLambda&&... qobjectsAndLambda) {
static_assert(sizeof...(PointersAndLambda) > 0, "Lambda should be passed here."); static_assert(sizeof...(PointersAndLambda) > 0, "Lambda should be passed here.");
return internal::lambda_guard_t<PointersAndLambda...>(std::forward<PointersAndLambda>(qobjectsAndLambda)...); return lambda_internal::guard_t<PointersAndLambda...>(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
} }
// Pass lambda instead of a Qt void() slot. // Pass lambda instead of a Qt void() slot.
@ -545,20 +583,20 @@ class lambda_slot_wrap : public QObject {
Q_OBJECT Q_OBJECT
public: public:
lambda_slot_wrap(QObject *parent, lambda<void()> &&lambda) : QObject(parent), _lambda(std::move(lambda)) { lambda_slot_wrap(QObject *parent, lambda_once<void()> lambda) : QObject(parent), _lambda(std::move(lambda)) {
} }
public slots: public slots :
void action() { void action() {
_lambda(); _lambda();
} }
private: private:
lambda<void()> _lambda; lambda_once<void()> _lambda;
}; };
inline lambda_slot_wrap *lambda_slot(QObject *parent, lambda<void()> &&lambda) { inline lambda_slot_wrap *lambda_slot(QObject *parent, lambda_once<void()> lambda) {
return new lambda_slot_wrap(parent, std::move(lambda)); return new lambda_slot_wrap(parent, std::move(lambda));
} }
@ -566,21 +604,21 @@ class lambda_slot_once_wrap : public QObject {
Q_OBJECT Q_OBJECT
public: public:
lambda_slot_once_wrap(QObject *parent, lambda<void()> &&lambda) : QObject(parent), _lambda(std::move(lambda)) { lambda_slot_once_wrap(QObject *parent, lambda_once<void()> lambda) : QObject(parent), _lambda(std::move(lambda)) {
} }
public slots : public slots :
void action() { void action() {
_lambda(); _lambda();
delete this; delete this;
} }
private: private:
lambda<void()> _lambda; lambda_once<void()> _lambda;
}; };
inline lambda_slot_once_wrap *lambda_slot_once(QObject *parent, lambda<void()> &&lambda) { inline lambda_slot_once_wrap *lambda_slot_once(QObject *parent, lambda_once<void()> lambda) {
return new lambda_slot_once_wrap(parent, std::move(lambda)); return new lambda_slot_once_wrap(parent, std::move(lambda));
} }

2
Telegram/SourceFiles/core/single_timer.cpp
View file

@ -28,7 +28,7 @@ SingleTimer::SingleTimer(QObject *parent) : QTimer(parent) {
Sandbox::connect(SIGNAL(adjustSingleTimers()), this, SLOT(adjust())); Sandbox::connect(SIGNAL(adjustSingleTimers()), this, SLOT(adjust()));
} }
void SingleTimer::setTimeoutHandler(base::lambda<void()> &&handler) { void SingleTimer::setTimeoutHandler(base::lambda<void()> handler) {
if (_handler && !handler) { if (_handler && !handler) {
disconnect(this, SIGNAL(timeout()), this, SLOT(onTimeout())); disconnect(this, SIGNAL(timeout()), this, SLOT(onTimeout()));
} else if (handler && !_handler) { } else if (handler && !_handler) {

2
Telegram/SourceFiles/core/single_timer.h
View file

@ -31,7 +31,7 @@ public:
void setSingleShot(bool); // is not available void setSingleShot(bool); // is not available
void start(); // is not available void start(); // is not available
void setTimeoutHandler(base::lambda<void()> &&handler); void setTimeoutHandler(base::lambda<void()> handler);
public slots: public slots:
void start(int msec); void start(int msec);

19
Telegram/SourceFiles/core/task_queue.cpp
View file

@ -195,7 +195,7 @@ TaskQueue *TaskQueue::TaskQueueList::TakeFirst(int list_index_) {
void TaskQueue::TaskThreadPool::AddQueueTask(TaskQueue *queue, Task &&task) { void TaskQueue::TaskThreadPool::AddQueueTask(TaskQueue *queue, Task &&task) {
QMutexLocker lock(&queues_mutex_); QMutexLocker lock(&queues_mutex_);
queue->tasks_.push_back(new Task(std::move(task))); queue->tasks_.push_back(std::move(task));
auto list_was_empty = queue_list_.Empty(kAllQueuesList); auto list_was_empty = queue_list_.Empty(kAllQueuesList);
auto threads_count = threads_.size(); auto threads_count = threads_.size();
auto all_threads_processing = (threads_count == tasks_in_process_); auto all_threads_processing = (threads_count == tasks_in_process_);
@ -258,7 +258,7 @@ void TaskQueue::TaskThreadPool::ThreadFunction() {
bool serial_queue_destroyed = false; bool serial_queue_destroyed = false;
bool task_was_processed = false; bool task_was_processed = false;
while (true) { while (true) {
std::unique_ptr<Task> task; Task task;
{ {
QMutexLocker lock(&queues_mutex_); QMutexLocker lock(&queues_mutex_);
@ -297,7 +297,7 @@ void TaskQueue::TaskThreadPool::ThreadFunction() {
t_assert(!queue->tasks_.empty()); t_assert(!queue->tasks_.empty());
task.reset(queue->tasks_.front()); task = std::move(queue->tasks_.front());
queue->tasks_.pop_front(); queue->tasks_.pop_front();
if (queue->type_ == Type::Serial) { if (queue->type_ == Type::Serial) {
@ -318,7 +318,7 @@ void TaskQueue::TaskThreadPool::ThreadFunction() {
} }
} }
(*task)(); task();
} }
} }
@ -336,15 +336,12 @@ TaskQueue::~TaskQueue() {
thread_pool->RemoveQueue(this); thread_pool->RemoveQueue(this);
} }
} }
for (auto task : take(tasks_)) {
delete task;
}
} }
void TaskQueue::Put(Task &&task) { void TaskQueue::Put(Task &&task) {
if (type_ == Type::Main) { if (type_ == Type::Main) {
QMutexLocker lock(&tasks_mutex_); QMutexLocker lock(&tasks_mutex_);
tasks_.push_back(new Task(std::move(task))); tasks_.push_back(std::move(task));
Sandbox::MainThreadTaskAdded(); Sandbox::MainThreadTaskAdded();
} else { } else {
@ -372,7 +369,7 @@ void TaskQueue::ProcessMainTasks(TimeMs max_time_spent) { // static
} }
bool TaskQueue::ProcessOneMainTask() { // static bool TaskQueue::ProcessOneMainTask() { // static
std::unique_ptr<Task> task; Task task;
{ {
QMutexLocker lock(&Main().tasks_mutex_); QMutexLocker lock(&Main().tasks_mutex_);
auto &tasks = Main().tasks_; auto &tasks = Main().tasks_;
@ -380,11 +377,11 @@ bool TaskQueue::ProcessOneMainTask() { // static
return false; return false;
} }
task.reset(tasks.front()); task = std::move(tasks.front());
tasks.pop_front(); tasks.pop_front();
} }
(*task)(); task();
return true; return true;
} }

4
Telegram/SourceFiles/core/task_queue.h
View file

@ -22,7 +22,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
namespace base { namespace base {
using Task = lambda<void()>; using Task = lambda_once<void()>;
// An attempt to create/use a TaskQueue or one of the default queues // An attempt to create/use a TaskQueue or one of the default queues
// after the main() has returned leads to an undefined behaviour. // after the main() has returned leads to an undefined behaviour.
@ -69,7 +69,7 @@ private:
const Type type_; const Type type_;
const Priority priority_; const Priority priority_;
QList<Task*> tasks_; // TODO: std::deque<Task> std::deque<Task> tasks_;
QMutex tasks_mutex_; // Only for the main queue. QMutex tasks_mutex_; // Only for the main queue.
// Only for the other queues, not main. // Only for the other queues, not main.

2
Telegram/SourceFiles/dialogs/dialogs_row.cpp
View file

@ -30,7 +30,7 @@ namespace Dialogs {
RippleRow::RippleRow() = default; RippleRow::RippleRow() = default;
RippleRow::~RippleRow() = default; RippleRow::~RippleRow() = default;
void RippleRow::addRipple(QPoint origin, QSize size, base::lambda_copy<void()> &&updateCallback) { void RippleRow::addRipple(QPoint origin, QSize size, base::lambda<void()> updateCallback) {
if (!_ripple) { if (!_ripple) {
auto mask = Ui::RippleAnimation::rectMask(size); auto mask = Ui::RippleAnimation::rectMask(size);
_ripple = std::make_unique<Ui::RippleAnimation>(st::dialogsRipple, std::move(mask), std::move(updateCallback)); _ripple = std::make_unique<Ui::RippleAnimation>(st::dialogsRipple, std::move(mask), std::move(updateCallback));

2
Telegram/SourceFiles/dialogs/dialogs_row.h
View file

@ -39,7 +39,7 @@ public:
RippleRow(); RippleRow();
~RippleRow(); ~RippleRow();
void addRipple(QPoint origin, QSize size, base::lambda_copy<void()> &&updateCallback); void addRipple(QPoint origin, QSize size, base::lambda<void()> updateCallback);
void stopLastRipple(); void stopLastRipple();
void paintRipple(Painter &p, int x, int y, int outerWidth, TimeMs ms, const QColor *colorOverride = nullptr) const; void paintRipple(Painter &p, int x, int y, int outerWidth, TimeMs ms, const QColor *colorOverride = nullptr) const;

2
Telegram/SourceFiles/dialogswidget.cpp
View file

@ -1185,7 +1185,7 @@ void DialogsInner::contextMenuEvent(QContextMenuEvent *e) {
} }
_menu = new Ui::PopupMenu(nullptr); _menu = new Ui::PopupMenu(nullptr);
App::main()->fillPeerMenu(_menuPeer, [this](const QString &text, base::lambda<void()> &&callback) { App::main()->fillPeerMenu(_menuPeer, [this](const QString &text, base::lambda<void()> callback) {
return _menu->addAction(text, std::move(callback)); return _menu->addAction(text, std::move(callback));
}, true); }, true);
connect(_menu, SIGNAL(destroyed(QObject*)), this, SLOT(onMenuDestroyed(QObject*))); connect(_menu, SIGNAL(destroyed(QObject*)), this, SLOT(onMenuDestroyed(QObject*)));

2
Telegram/SourceFiles/dialogswidget.h
View file

@ -112,7 +112,7 @@ public:
PeerData *updateFromParentDrag(QPoint globalPos); PeerData *updateFromParentDrag(QPoint globalPos);
void setLoadMoreCallback(base::lambda<void()> &&callback) { void setLoadMoreCallback(base::lambda<void()> callback) {
_loadMoreCallback = std::move(callback); _loadMoreCallback = std::move(callback);
} }
void setVisibleTopBottom(int visibleTop, int visibleBottom) override; void setVisibleTopBottom(int visibleTop, int visibleBottom) override;

2
Telegram/SourceFiles/facades.cpp
View file

@ -38,7 +38,7 @@ Q_DECLARE_METATYPE(Ui::ShowWay);
namespace App { namespace App {
namespace internal { namespace internal {
void CallDelayed(int duration, base::lambda<void()> &&lambda) { void CallDelayed(int duration, base::lambda_once<void()> &&lambda) {
QTimer::singleShot(duration, base::lambda_slot_once(App::app(), std::move(lambda)), SLOT(action())); QTimer::singleShot(duration, base::lambda_slot_once(App::app(), std::move(lambda)), SLOT(action()));
} }

14
Telegram/SourceFiles/facades.h
View file

@ -35,12 +35,12 @@ class ItemBase;
namespace App { namespace App {
namespace internal { namespace internal {
void CallDelayed(int duration, base::lambda<void()> &&lambda); void CallDelayed(int duration, base::lambda_once<void()> &&lambda);
} // namespace internal } // namespace internal
template <int N, typename Lambda> template <int N, typename Lambda>
inline void CallDelayed(int duration, base::internal::lambda_guard<N, Lambda> &&guarded) { inline void CallDelayed(int duration, base::lambda_internal::guard<N, Lambda> &&guarded) {
return internal::CallDelayed(duration, [guarded = std::move(guarded)] { guarded(); }); return internal::CallDelayed(duration, [guarded = std::move(guarded)] { guarded(); });
} }
@ -54,7 +54,15 @@ template <typename ...PointersAndLambda>
inline base::lambda<void()> LambdaDelayed(int duration, PointersAndLambda&&... qobjectsAndLambda) { inline base::lambda<void()> LambdaDelayed(int duration, PointersAndLambda&&... qobjectsAndLambda) {
auto guarded = base::lambda_guarded(std::forward<PointersAndLambda>(qobjectsAndLambda)...); auto guarded = base::lambda_guarded(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
return [guarded = std::move(guarded), duration] { return [guarded = std::move(guarded), duration] {
CallDelayed(duration, guarded.clone()); internal::CallDelayed(duration, [guarded] { guarded(); });
};
}
template <typename ...PointersAndLambda>
inline base::lambda_once<void()> LambdaDelayedOnce(int duration, PointersAndLambda&&... qobjectsAndLambda) {
auto guarded = base::lambda_guarded(std::forward<PointersAndLambda>(qobjectsAndLambda)...);
return [guarded = std::move(guarded), duration]() mutable {
internal::CallDelayed(duration, [guarded = std::move(guarded)] { guarded(); });
}; };
} }

2
Telegram/SourceFiles/history/history_drag_area.h
View file

@ -37,7 +37,7 @@ public:
void hideFast(); void hideFast();
void setDroppedCallback(base::lambda<void(const QMimeData *data)> &&callback) { void setDroppedCallback(base::lambda<void(const QMimeData *data)> callback) {
_droppedCallback = std::move(callback); _droppedCallback = std::move(callback);
} }

4
Telegram/SourceFiles/intro/introwidget.cpp
View file

@ -722,11 +722,11 @@ void Widget::Step::showAnimated(Direction direction) {
} }
} }
void Widget::Step::setGoCallback(base::lambda<void(Step *step, Direction direction)> &&callback) { void Widget::Step::setGoCallback(base::lambda<void(Step *step, Direction direction)> callback) {
_goCallback = std::move(callback); _goCallback = std::move(callback);
} }
void Widget::Step::setShowResetCallback(base::lambda<void()> &&callback) { void Widget::Step::setShowResetCallback(base::lambda<void()> callback) {
_showResetCallback = std::move(callback); _showResetCallback = std::move(callback);
} }

4
Telegram/SourceFiles/intro/introwidget.h
View file

@ -100,8 +100,8 @@ public:
setFocus(); setFocus();
} }
void setGoCallback(base::lambda<void(Step *step, Direction direction)> &&callback); void setGoCallback(base::lambda<void(Step *step, Direction direction)> callback);
void setShowResetCallback(base::lambda<void()> &&callback); void setShowResetCallback(base::lambda<void()> callback);
void prepareShowAnimated(Step *after); void prepareShowAnimated(Step *after);
void showAnimated(Direction direction); void showAnimated(Direction direction);

2
Telegram/SourceFiles/layerwidget.cpp
View file

@ -45,7 +45,7 @@ public:
BackgroundWidget(QWidget *parent) : TWidget(parent) { BackgroundWidget(QWidget *parent) : TWidget(parent) {
} }
void setDoneCallback(base::lambda<void()> &&callback) { void setDoneCallback(base::lambda<void()> callback) {
_doneCallback = std::move(callback); _doneCallback = std::move(callback);
} }

4
Telegram/SourceFiles/layerwidget.h
View file

@ -45,10 +45,10 @@ public:
bool overlaps(const QRect &globalRect); bool overlaps(const QRect &globalRect);
void setClosedCallback(base::lambda<void()> &&callback) { void setClosedCallback(base::lambda<void()> callback) {
_closedCallback = std::move(callback); _closedCallback = std::move(callback);
} }
void setResizedCallback(base::lambda<void()> &&callback) { void setResizedCallback(base::lambda<void()> callback) {
_resizedCallback = std::move(callback); _resizedCallback = std::move(callback);
} }

2
Telegram/SourceFiles/mainwidget.cpp
View file

@ -1970,7 +1970,7 @@ void MainWidget::scheduleViewIncrement(HistoryItem *item) {
j.value().insert(item->id, true); j.value().insert(item->id, true);
} }
void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> &&handler)> &&callback, bool pinToggle) { void MainWidget::fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> handler)> callback, bool pinToggle) {
if (pinToggle) { if (pinToggle) {
auto isPinned = false; auto isPinned = false;
if (auto history = App::historyLoaded(peer)) { if (auto history = App::historyLoaded(peer)) {

2
Telegram/SourceFiles/mainwidget.h
View file

@ -367,7 +367,7 @@ public:
void scheduleViewIncrement(HistoryItem *item); void scheduleViewIncrement(HistoryItem *item);
void fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> &&handler)> &&callback, bool pinToggle); void fillPeerMenu(PeerData *peer, base::lambda<QAction*(const QString &text, base::lambda<void()> handler)> callback, bool pinToggle);
void gotRangeDifference(ChannelData *channel, const MTPupdates_ChannelDifference &diff); void gotRangeDifference(ChannelData *channel, const MTPupdates_ChannelDifference &diff);
void onSelfParticipantUpdated(ChannelData *channel); void onSelfParticipantUpdated(ChannelData *channel);

2
Telegram/SourceFiles/media/player/media_player_button.cpp
View file

@ -45,7 +45,7 @@ QPainterPath interpolatePaths(QPointF (&from)[N], QPointF (&to)[N], float64 k) {
} // namespace } // namespace
PlayButtonLayout::PlayButtonLayout(const style::MediaPlayerButton &st, base::lambda<void()> &&callback) PlayButtonLayout::PlayButtonLayout(const style::MediaPlayerButton &st, base::lambda<void()> callback)
: _st(st) : _st(st)
, _callback(std::move(callback)) { , _callback(std::move(callback)) {
} }

2
Telegram/SourceFiles/media/player/media_player_button.h
View file

@ -33,7 +33,7 @@ public:
Pause, Pause,
Cancel, Cancel,
}; };
PlayButtonLayout(const style::MediaPlayerButton &st, base::lambda<void()> &&callback); PlayButtonLayout(const style::MediaPlayerButton &st, base::lambda<void()> callback);
void setState(State state); void setState(State state);
void finishTransform(); void finishTransform();

2
Telegram/SourceFiles/media/player/media_player_panel.h
View file

@ -48,7 +48,7 @@ public:
void showFromOther(); void showFromOther();
void hideFromOther(); void hideFromOther();
using ButtonCallback = base::lambda_copy<void()>; using ButtonCallback = base::lambda<void()>;
void setPinCallback(ButtonCallback &&callback); void setPinCallback(ButtonCallback &&callback);
void setCloseCallback(ButtonCallback &&callback); void setCloseCallback(ButtonCallback &&callback);

17
Telegram/SourceFiles/mediaview.cpp
View file

@ -1446,24 +1446,15 @@ void MediaView::initThemePreview() {
} }
update(); update();
}); });
struct mutable_ready {
mutable_ready(decltype(ready) value) : value(std::move(value)) {
}
mutable decltype(ready) value;
};
struct mutable_result {
mutable_result(std::unique_ptr<Window::Theme::Preview> value) : value(std::move(value)) {
}
mutable std::unique_ptr<Window::Theme::Preview> value;
};
Window::Theme::CurrentData current; Window::Theme::CurrentData current;
current.backgroundId = Window::Theme::Background()->id(); current.backgroundId = Window::Theme::Background()->id();
current.backgroundImage = Window::Theme::Background()->pixmap(); current.backgroundImage = Window::Theme::Background()->pixmap();
current.backgroundTiled = Window::Theme::Background()->tile(); current.backgroundTiled = Window::Theme::Background()->tile();
base::TaskQueue::Normal().Put([path, current, callback = mutable_ready(std::move(ready))]() { base::TaskQueue::Normal().Put([ready = std::move(ready), path, current]() mutable {
auto preview = Window::Theme::GeneratePreview(path, current); auto preview = Window::Theme::GeneratePreview(path, current);
base::TaskQueue::Main().Put([result = mutable_result(std::move(preview)), callback = std::move(callback.value)]() { base::TaskQueue::Main().Put([ready = std::move(ready), result = std::move(preview)]() mutable {
callback(std::move(result.value)); ready(std::move(result));
}); });
}); });
location.accessDisable(); location.accessDisable();

12
Telegram/SourceFiles/mtproto/mtp_instance.cpp
View file

@ -87,8 +87,8 @@ public:
void setUpdatesHandler(RPCDoneHandlerPtr onDone); void setUpdatesHandler(RPCDoneHandlerPtr onDone);
void setGlobalFailHandler(RPCFailHandlerPtr onFail); void setGlobalFailHandler(RPCFailHandlerPtr onFail);
void setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> &&handler); void setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> handler);
void setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> &&handler); void setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> handler);
void clearGlobalHandlers(); void clearGlobalHandlers();
internal::Session *getSession(ShiftedDcId shiftedDcId); internal::Session *getSession(ShiftedDcId shiftedDcId);
@ -1173,11 +1173,11 @@ void Instance::Private::setGlobalFailHandler(RPCFailHandlerPtr onFail) {
_globalHandler.onFail = onFail; _globalHandler.onFail = onFail;
} }
void Instance::Private::setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> &&handler) { void Instance::Private::setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> handler) {
_stateChangedHandler = std::move(handler); _stateChangedHandler = std::move(handler);
} }
void Instance::Private::setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> &&handler) { void Instance::Private::setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> handler) {
_sessionResetHandler = std::move(handler); _sessionResetHandler = std::move(handler);
} }
@ -1298,11 +1298,11 @@ void Instance::setGlobalFailHandler(RPCFailHandlerPtr onFail) {
_private->setGlobalFailHandler(onFail); _private->setGlobalFailHandler(onFail);
} }
void Instance::setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> &&handler) { void Instance::setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> handler) {
_private->setStateChangedHandler(std::move(handler)); _private->setStateChangedHandler(std::move(handler));
} }
void Instance::setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> &&handler) { void Instance::setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> handler) {
_private->setSessionResetHandler(std::move(handler)); _private->setSessionResetHandler(std::move(handler));
} }

4
Telegram/SourceFiles/mtproto/mtp_instance.h
View file

@ -97,8 +97,8 @@ public:
void setUpdatesHandler(RPCDoneHandlerPtr onDone); void setUpdatesHandler(RPCDoneHandlerPtr onDone);
void setGlobalFailHandler(RPCFailHandlerPtr onFail); void setGlobalFailHandler(RPCFailHandlerPtr onFail);
void setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> &&handler); void setStateChangedHandler(base::lambda<void(ShiftedDcId shiftedDcId, int32 state)> handler);
void setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> &&handler); void setSessionResetHandler(base::lambda<void(ShiftedDcId shiftedDcId)> handler);
void clearGlobalHandlers(); void clearGlobalHandlers();
void onStateChange(ShiftedDcId dcWithShift, int32 state); void onStateChange(ShiftedDcId dcWithShift, int32 state);

30
Telegram/SourceFiles/mtproto/rpc_sender.h
View file

@ -834,7 +834,7 @@ protected:
using Parent = RPCHandlerImplementation<Base, FunctionType>; using Parent = RPCHandlerImplementation<Base, FunctionType>;
public: public:
RPCHandlerImplementation(Lambda &&handler) : _handler(std::move(handler)) { RPCHandlerImplementation(Lambda handler) : _handler(std::move(handler)) {
} }
protected: protected:
@ -906,37 +906,37 @@ public:
}; };
template <typename R> template <typename R>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*)> &&lambda) { inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationBare<R>(std::move(lambda))); return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationBare<R>(std::move(lambda)));
} }
template <typename R> template <typename R>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*, mtpRequestId)> &&lambda) { inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const mtpPrime*, const mtpPrime*, mtpRequestId)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationBareReq<R>(std::move(lambda))); return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationBareReq<R>(std::move(lambda)));
} }
template <typename R, typename T> template <typename R, typename T>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const T&)> &&lambda) { inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const T&)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationPlain<R, T>(std::move(lambda))); return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationPlain<R, T>(std::move(lambda)));
} }
template <typename R, typename T> template <typename R, typename T>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const T&, mtpRequestId)> &&lambda) { inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(const T&, mtpRequestId)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationReq<R, T>(std::move(lambda))); return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationReq<R, T>(std::move(lambda)));
} }
template <typename R> template <typename R>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R()> &&lambda) { inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R()> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNo<R>(std::move(lambda))); return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNo<R>(std::move(lambda)));
} }
template <typename R> template <typename R>
inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(mtpRequestId)> &&lambda) { inline RPCDoneHandlerPtr rpcDone_lambda_wrap_helper(base::lambda<R(mtpRequestId)> lambda) {
return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNoReq<R>(std::move(lambda))); return RPCDoneHandlerPtr(new RPCDoneHandlerImplementationNoReq<R>(std::move(lambda)));
} }
template <typename Lambda, typename = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>> template <typename Lambda>
RPCDoneHandlerPtr rpcDone(Lambda &&lambda) { RPCDoneHandlerPtr rpcDone(Lambda lambda) {
return rpcDone_lambda_wrap_helper(base::lambda_type<Lambda>(std::move(lambda))); return rpcDone_lambda_wrap_helper(base::lambda_type<Lambda>(std::move(lambda)));
} }
@ -979,23 +979,23 @@ public:
}; };
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&)> &&lambda) { inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&)> lambda) {
return RPCFailHandlerPtr(new RPCFailHandlerImplementationPlain(std::move(lambda))); return RPCFailHandlerPtr(new RPCFailHandlerImplementationPlain(std::move(lambda)));
} }
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&, mtpRequestId)> &&lambda) { inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(const RPCError&, mtpRequestId)> lambda) {
return RPCFailHandlerPtr(new RPCFailHandlerImplementationReq(std::move(lambda))); return RPCFailHandlerPtr(new RPCFailHandlerImplementationReq(std::move(lambda)));
} }
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool()> &&lambda) { inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool()> lambda) {
return RPCFailHandlerPtr(new RPCFailHandlerImplementationNo(std::move(lambda))); return RPCFailHandlerPtr(new RPCFailHandlerImplementationNo(std::move(lambda)));
} }
inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(mtpRequestId)> &&lambda) { inline RPCFailHandlerPtr rpcFail_lambda_wrap_helper(base::lambda<bool(mtpRequestId)> lambda) {
return RPCFailHandlerPtr(new RPCFailHandlerImplementationNoReq(std::move(lambda))); return RPCFailHandlerPtr(new RPCFailHandlerImplementationNoReq(std::move(lambda)));
} }
template <typename Lambda, typename = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>> template <typename Lambda>
RPCFailHandlerPtr rpcFail(Lambda &&lambda) { RPCFailHandlerPtr rpcFail(Lambda lambda) {
return rpcFail_lambda_wrap_helper(base::lambda_type<Lambda>(std::move(lambda))); return rpcFail_lambda_wrap_helper(base::lambda_type<Lambda>(std::move(lambda)));
} }

2
Telegram/SourceFiles/overview/overview_layout.cpp
View file

@ -156,7 +156,7 @@ public:
private: private:
void startAnimation(); void startAnimation();
base::lambda_copy<void()> _updateCallback; base::lambda<void()> _updateCallback;
Ui::RoundCheckbox _check; Ui::RoundCheckbox _check;
Animation _pression; Animation _pression;

8
Telegram/SourceFiles/profile/profile_block_peer_list.h
View file

@ -81,16 +81,16 @@ public:
qSort(_items.begin(), _items.end(), std::move(predicate)); qSort(_items.begin(), _items.end(), std::move(predicate));
} }
void setPreloadMoreCallback(base::lambda<void()> &&callback) { void setPreloadMoreCallback(base::lambda<void()> callback) {
_preloadMoreCallback = std::move(callback); _preloadMoreCallback = std::move(callback);
} }
void setSelectedCallback(base::lambda<void(PeerData*)> &&callback) { void setSelectedCallback(base::lambda<void(PeerData*)> callback) {
_selectedCallback = std::move(callback); _selectedCallback = std::move(callback);
} }
void setRemovedCallback(base::lambda<void(PeerData*)> &&callback) { void setRemovedCallback(base::lambda<void(PeerData*)> callback) {
_removedCallback = std::move(callback); _removedCallback = std::move(callback);
} }
void setUpdateItemCallback(base::lambda<void(Item*)> &&callback) { void setUpdateItemCallback(base::lambda<void(Item*)> callback) {
_updateItemCallback = std::move(callback); _updateItemCallback = std::move(callback);
} }

2
Telegram/SourceFiles/settings/settings_layer.cpp
View file

@ -54,7 +54,7 @@ Layer::Layer()
connect(_scroll, SIGNAL(scrolled()), this, SLOT(onScroll())); connect(_scroll, SIGNAL(scrolled()), this, SLOT(onScroll()));
} }
void Layer::setCloseClickHandler(base::lambda<void()> &&callback) { void Layer::setCloseClickHandler(base::lambda<void()> callback) {
_fixedBarClose->setClickedCallback(std::move(callback)); _fixedBarClose->setClickedCallback(std::move(callback));
} }

2
Telegram/SourceFiles/settings/settings_layer.h
View file

@ -51,7 +51,7 @@ class Layer : public LayerWidget {
public: public:
Layer(); Layer();
void setCloseClickHandler(base::lambda<void()> &&callback); void setCloseClickHandler(base::lambda<void()> callback);
void resizeToWidth(int newWidth, int newContentLeft); void resizeToWidth(int newWidth, int newContentLeft);
protected: protected:

2
Telegram/SourceFiles/settings/settings_widget.cpp
View file

@ -43,7 +43,7 @@ namespace Settings {
namespace { namespace {
QString SecretText; QString SecretText;
QMap<QString, base::lambda_copy<void()>> Codes; QMap<QString, base::lambda<void()>> Codes;
void fillCodes() { void fillCodes() {
Codes.insert(qsl("debugmode"), []() { Codes.insert(qsl("debugmode"), []() {

2
Telegram/SourceFiles/ui/abstract_button.h
View file

@ -52,7 +52,7 @@ public:
void setAcceptBoth(bool acceptBoth = true); void setAcceptBoth(bool acceptBoth = true);
void setClickedCallback(base::lambda<void()> &&callback) { void setClickedCallback(base::lambda<void()> callback) {
_clickedCallback = std::move(callback); _clickedCallback = std::move(callback);
} }

15
Telegram/SourceFiles/ui/animation.h
View file

@ -88,7 +88,7 @@ enum Notification {
namespace anim { namespace anim {
using transition = base::lambda_copy<float64(float64 delta, float64 dt)>; using transition = base::lambda<float64(float64 delta, float64 dt)>;
extern transition linear; extern transition linear;
extern transition sineInOut; extern transition sineInOut;
@ -141,7 +141,7 @@ public:
_from += delta; _from += delta;
_cur += delta; _cur += delta;
} }
value &update(float64 dt, const transition &func) { value &update(float64 dt, transition func) {
_cur = _from + func(_delta, dt); _cur = _from + func(_delta, dt);
return *this; return *this;
} }
@ -590,7 +590,7 @@ public:
static constexpr auto kLongAnimationDuration = 1000; static constexpr auto kLongAnimationDuration = 1000;
template <typename Lambda> template <typename Lambda>
void start(Lambda &&updateCallback, float64 from, float64 to, float64 duration, const anim::transition &transition = anim::linear) { void start(Lambda &&updateCallback, float64 from, float64 to, float64 duration, anim::transition transition = anim::linear) {
auto isLong = (duration >= kLongAnimationDuration); auto isLong = (duration >= kLongAnimationDuration);
if (_data) { if (_data) {
if (!isLong) { if (!isLong) {
@ -618,17 +618,12 @@ public:
private: private:
struct Data { struct Data {
template <typename Lambda, typename = std::enable_if_t<std::is_rvalue_reference<Lambda&&>::value>> template <typename Lambda>
Data(float64 from, Lambda &&updateCallback) Data(float64 from, Lambda updateCallback)
: value(from, from) : value(from, from)
, a_animation(animation(this, &Data::step)) , a_animation(animation(this, &Data::step))
, updateCallback(std::move(updateCallback)) { , updateCallback(std::move(updateCallback)) {
} }
Data(float64 from, const base::lambda_copy<void()> &updateCallback)
: value(from, from)
, a_animation(animation(this, &Data::step))
, updateCallback(base::lambda_copy<void()>(updateCallback)) {
}
void step(float64 ms, bool timer) { void step(float64 ms, bool timer) {
auto dt = (ms >= duration) ? 1. : (ms / duration); auto dt = (ms >= duration) ? 1. : (ms / duration);
if (dt >= 1) { if (dt >= 1) {

8
Telegram/SourceFiles/ui/buttons/history_down_button.h
View file

@ -92,16 +92,16 @@ public:
void setRecordActive(bool recordActive); void setRecordActive(bool recordActive);
void finishAnimation(); void finishAnimation();
void setRecordStartCallback(base::lambda<void()> &&callback) { void setRecordStartCallback(base::lambda<void()> callback) {
_recordStartCallback = std::move(callback); _recordStartCallback = std::move(callback);
} }
void setRecordUpdateCallback(base::lambda<void(QPoint globalPos)> &&callback) { void setRecordUpdateCallback(base::lambda<void(QPoint globalPos)> callback) {
_recordUpdateCallback = std::move(callback); _recordUpdateCallback = std::move(callback);
} }
void setRecordStopCallback(base::lambda<void(bool active)> &&callback) { void setRecordStopCallback(base::lambda<void(bool active)> callback) {
_recordStopCallback = std::move(callback); _recordStopCallback = std::move(callback);
} }
void setRecordAnimationCallback(base::lambda<void()> &&callback) { void setRecordAnimationCallback(base::lambda<void()> callback) {
_recordAnimationCallback = std::move(callback); _recordAnimationCallback = std::move(callback);
} }

2
Telegram/SourceFiles/ui/effects/ripple_animation.cpp
View file

@ -195,7 +195,7 @@ void RippleAnimation::paint(QPainter &p, int x, int y, int outerWidth, TimeMs ms
clearFinished(); clearFinished();
} }
QImage RippleAnimation::maskByDrawer(QSize size, bool filled, base::lambda<void(QPainter &p)> &&drawer) { QImage RippleAnimation::maskByDrawer(QSize size, bool filled, base::lambda<void(QPainter &p)> drawer) {
auto result = QImage(size * cIntRetinaFactor(), QImage::Format_ARGB32_Premultiplied); auto result = QImage(size * cIntRetinaFactor(), QImage::Format_ARGB32_Premultiplied);
result.setDevicePixelRatio(cRetinaFactor()); result.setDevicePixelRatio(cRetinaFactor());
result.fill(filled ? QColor(255, 255, 255) : Qt::transparent); result.fill(filled ? QColor(255, 255, 255) : Qt::transparent);

4
Telegram/SourceFiles/ui/effects/ripple_animation.h
View file

@ -26,7 +26,7 @@ namespace Ui {
class RippleAnimation { class RippleAnimation {
public: public:
using UpdateCallback = base::lambda_copy<void()>; using UpdateCallback = base::lambda<void()>;
// White upon transparent mask, like colorizeImage(black-white-mask, white). // White upon transparent mask, like colorizeImage(black-white-mask, white).
RippleAnimation(const style::RippleAnimation &st, QImage mask, const UpdateCallback &update); RippleAnimation(const style::RippleAnimation &st, QImage mask, const UpdateCallback &update);
@ -43,7 +43,7 @@ public:
return _ripples.isEmpty(); return _ripples.isEmpty();
} }
static QImage maskByDrawer(QSize size, bool filled, base::lambda<void(QPainter &p)> &&drawer); static QImage maskByDrawer(QSize size, bool filled, base::lambda<void(QPainter &p)> drawer);
static QImage rectMask(QSize size); static QImage rectMask(QSize size);
static QImage roundRectMask(QSize size, int radius); static QImage roundRectMask(QSize size, int radius);
static QImage ellipseMask(QSize size); static QImage ellipseMask(QSize size);

4
Telegram/SourceFiles/ui/effects/round_checkbox.cpp
View file

@ -59,7 +59,7 @@ void prepareCheckCaches(const style::RoundCheckbox *st, bool displayInactive, QP
} // namespace } // namespace
RoundCheckbox::RoundCheckbox(const style::RoundCheckbox &st, const base::lambda_copy<void()> &updateCallback) RoundCheckbox::RoundCheckbox(const style::RoundCheckbox &st, base::lambda<void()> updateCallback)
: _st(st) : _st(st)
, _updateCallback(updateCallback) { , _updateCallback(updateCallback) {
} }
@ -232,7 +232,7 @@ void RoundCheckbox::prepareInactiveCache() {
_inactiveCacheFg = App::pixmapFromImageInPlace(std::move(cacheFg)); _inactiveCacheFg = App::pixmapFromImageInPlace(std::move(cacheFg));
} }
RoundImageCheckbox::RoundImageCheckbox(const style::RoundImageCheckbox &st, const base::lambda_copy<void()> &updateCallback, PaintRoundImage &&paintRoundImage) RoundImageCheckbox::RoundImageCheckbox(const style::RoundImageCheckbox &st, base::lambda<void()> updateCallback, PaintRoundImage &&paintRoundImage)
: _st(st) : _st(st)
, _updateCallback(updateCallback) , _updateCallback(updateCallback)
, _paintRoundImage(std::move(paintRoundImage)) , _paintRoundImage(std::move(paintRoundImage))

8
Telegram/SourceFiles/ui/effects/round_checkbox.h
View file

@ -26,7 +26,7 @@ namespace Ui {
class RoundCheckbox { class RoundCheckbox {
public: public:
RoundCheckbox(const style::RoundCheckbox &st, const base::lambda_copy<void()> &updateCallback); RoundCheckbox(const style::RoundCheckbox &st, base::lambda<void()> updateCallback);
void paint(Painter &p, TimeMs ms, int x, int y, int outerWidth, float64 masterScale = 1.); void paint(Painter &p, TimeMs ms, int x, int y, int outerWidth, float64 masterScale = 1.);
@ -54,7 +54,7 @@ private:
QRect cacheDestRect(int x, int y, float64 scale) const; QRect cacheDestRect(int x, int y, float64 scale) const;
const style::RoundCheckbox &_st; const style::RoundCheckbox &_st;
base::lambda_copy<void()> _updateCallback; base::lambda<void()> _updateCallback;
bool _checked = false; bool _checked = false;
std::vector<Icon> _icons; std::vector<Icon> _icons;
@ -70,7 +70,7 @@ private:
class RoundImageCheckbox { class RoundImageCheckbox {
public: public:
using PaintRoundImage = base::lambda<void(Painter &p, int x, int y, int outerWidth, int size)>; using PaintRoundImage = base::lambda<void(Painter &p, int x, int y, int outerWidth, int size)>;
RoundImageCheckbox(const style::RoundImageCheckbox &st, const base::lambda_copy<void()> &updateCallback, PaintRoundImage &&paintRoundImage); RoundImageCheckbox(const style::RoundImageCheckbox &st, base::lambda<void()> updateCallback, PaintRoundImage &&paintRoundImage);
void paint(Painter &p, TimeMs ms, int x, int y, int outerWidth); void paint(Painter &p, TimeMs ms, int x, int y, int outerWidth);
float64 checkedAnimationRatio() const; float64 checkedAnimationRatio() const;
@ -89,7 +89,7 @@ private:
void prepareWideCache(); void prepareWideCache();
const style::RoundImageCheckbox &_st; const style::RoundImageCheckbox &_st;
base::lambda_copy<void()> _updateCallback; base::lambda<void()> _updateCallback;
PaintRoundImage _paintRoundImage; PaintRoundImage _paintRoundImage;
QPixmap _wideCache; QPixmap _wideCache;

2
Telegram/SourceFiles/ui/effects/widget_fade_wrap.cpp
View file

@ -120,7 +120,7 @@ void FadeAnimation::updateCallback() {
WidgetFadeWrap<TWidget>::WidgetFadeWrap(QWidget *parent WidgetFadeWrap<TWidget>::WidgetFadeWrap(QWidget *parent
, object_ptr<TWidget> entity , object_ptr<TWidget> entity
, int duration , int duration
, base::lambda<void()> &&updateCallback) : TWidget(parent) , base::lambda<void()> updateCallback) : TWidget(parent)
, _entity(std::move(entity)) , _entity(std::move(entity))
, _duration(duration) , _duration(duration)
, _updateCallback(std::move(updateCallback)) , _updateCallback(std::move(updateCallback))

4
Telegram/SourceFiles/ui/effects/widget_fade_wrap.h
View file

@ -78,7 +78,7 @@ public:
WidgetFadeWrap(QWidget *parent WidgetFadeWrap(QWidget *parent
, object_ptr<TWidget> entity , object_ptr<TWidget> entity
, int duration = st::widgetFadeDuration , int duration = st::widgetFadeDuration
, base::lambda<void()> &&updateCallback = base::lambda<void()>()); , base::lambda<void()> updateCallback = base::lambda<void()>());
void showAnimated() { void showAnimated() {
_animation.fadeIn(_duration); _animation.fadeIn(_duration);
@ -140,7 +140,7 @@ public:
WidgetFadeWrap(QWidget *parent WidgetFadeWrap(QWidget *parent
, object_ptr<Widget> entity , object_ptr<Widget> entity
, int duration = st::widgetFadeDuration , int duration = st::widgetFadeDuration
, base::lambda<void()> &&updateCallback = base::lambda<void()>()) : WidgetFadeWrap<TWidget>(parent , base::lambda<void()> updateCallback = base::lambda<void()>()) : WidgetFadeWrap<TWidget>(parent
, std::move(entity) , std::move(entity)
, duration , duration
, std::move(updateCallback)) { , std::move(updateCallback)) {

2
Telegram/SourceFiles/ui/effects/widget_slide_wrap.cpp
View file

@ -26,7 +26,7 @@ namespace Ui {
WidgetSlideWrap<TWidget>::WidgetSlideWrap(QWidget *parent WidgetSlideWrap<TWidget>::WidgetSlideWrap(QWidget *parent
, object_ptr<TWidget> entity , object_ptr<TWidget> entity
, style::margins entityPadding , style::margins entityPadding
, base::lambda<void()> &&updateCallback , base::lambda<void()> updateCallback
, int duration) : TWidget(parent) , int duration) : TWidget(parent)
, _entity(std::move(entity)) , _entity(std::move(entity))
, _padding(entityPadding) , _padding(entityPadding)

4
Telegram/SourceFiles/ui/effects/widget_slide_wrap.h
View file

@ -33,7 +33,7 @@ public:
WidgetSlideWrap(QWidget *parent WidgetSlideWrap(QWidget *parent
, object_ptr<TWidget> entity , object_ptr<TWidget> entity
, style::margins entityPadding , style::margins entityPadding
, base::lambda<void()> &&updateCallback , base::lambda<void()> updateCallback
, int duration = st::widgetSlideDuration); , int duration = st::widgetSlideDuration);
void slideUp(); void slideUp();
@ -78,7 +78,7 @@ public:
WidgetSlideWrap(QWidget *parent WidgetSlideWrap(QWidget *parent
, object_ptr<Widget> entity , object_ptr<Widget> entity
, style::margins entityPadding , style::margins entityPadding
, base::lambda<void()> &&updateCallback , base::lambda<void()> updateCallback
, int duration = st::widgetSlideDuration) : WidgetSlideWrap<TWidget>(parent , int duration = st::widgetSlideDuration) : WidgetSlideWrap<TWidget>(parent
, std::move(entity) , std::move(entity)
, entityPadding , entityPadding

8
Telegram/SourceFiles/ui/filedialog.cpp
View file

@ -394,7 +394,7 @@ base::Observable<QueryUpdate> &QueryDone() {
return QueryDoneObservable; return QueryDoneObservable;
} }
void askOpenPath(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> &&callback, base::lambda<void()> &&failed) { void askOpenPath(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> callback, base::lambda<void()> failed) {
base::TaskQueue::Main().Put([caption, filter, callback = std::move(callback), failed = std::move(failed)] { base::TaskQueue::Main().Put([caption, filter, callback = std::move(callback), failed = std::move(failed)] {
auto file = QString(); auto file = QString();
auto remoteContent = QByteArray(); auto remoteContent = QByteArray();
@ -413,7 +413,7 @@ void askOpenPath(const QString &caption, const QString &filter, base::lambda<voi
}); });
} }
void askOpenPaths(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> &&callback, base::lambda<void()> &&failed) { void askOpenPaths(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> callback, base::lambda<void()> failed) {
base::TaskQueue::Main().Put([caption, filter, callback = std::move(callback), failed = std::move(failed)] { base::TaskQueue::Main().Put([caption, filter, callback = std::move(callback), failed = std::move(failed)] {
auto files = QStringList(); auto files = QStringList();
auto remoteContent = QByteArray(); auto remoteContent = QByteArray();
@ -431,7 +431,7 @@ void askOpenPaths(const QString &caption, const QString &filter, base::lambda<vo
} }
void askWritePath(const QString &caption, const QString &filter, const QString &initialPath, base::lambda<void(const QString &result)> &&callback, base::lambda<void()> &&failed) { void askWritePath(const QString &caption, const QString &filter, const QString &initialPath, base::lambda<void(const QString &result)> callback, base::lambda<void()> failed) {
base::TaskQueue::Main().Put([caption, filter, initialPath, callback = std::move(callback), failed = std::move(failed)] { base::TaskQueue::Main().Put([caption, filter, initialPath, callback = std::move(callback), failed = std::move(failed)] {
auto file = QString(); auto file = QString();
if (filedialogGetSaveFile(file, caption, filter, initialPath)) { if (filedialogGetSaveFile(file, caption, filter, initialPath)) {
@ -444,7 +444,7 @@ void askWritePath(const QString &caption, const QString &filter, const QString &
}); });
} }
void askFolder(const QString &caption, base::lambda<void(const QString &result)> &&callback, base::lambda<void()> &&failed) { void askFolder(const QString &caption, base::lambda<void(const QString &result)> callback, base::lambda<void()> failed) {
base::TaskQueue::Main().Put([caption, callback = std::move(callback), failed = std::move(failed)] { base::TaskQueue::Main().Put([caption, callback = std::move(callback), failed = std::move(failed)] {
auto folder = QString(); auto folder = QString();
if (filedialogGetDir(folder, caption) && !folder.isEmpty()) { if (filedialogGetDir(folder, caption) && !folder.isEmpty()) {

8
Telegram/SourceFiles/ui/filedialog.h
View file

@ -69,9 +69,9 @@ struct OpenResult {
QStringList paths; QStringList paths;
QByteArray remoteContent; QByteArray remoteContent;
}; };
void askOpenPath(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> &&callback, base::lambda<void()> &&failed = base::lambda<void()>()); void askOpenPath(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> callback, base::lambda<void()> failed = base::lambda<void()>());
void askOpenPaths(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> &&callback, base::lambda<void()> &&failed = base::lambda<void()>()); void askOpenPaths(const QString &caption, const QString &filter, base::lambda<void(const OpenResult &result)> callback, base::lambda<void()> failed = base::lambda<void()>());
void askWritePath(const QString &caption, const QString &filter, const QString &initialPath, base::lambda<void(const QString &result)> &&callback, base::lambda<void()> &&failed = base::lambda<void()>()); void askWritePath(const QString &caption, const QString &filter, const QString &initialPath, base::lambda<void(const QString &result)> callback, base::lambda<void()> failed = base::lambda<void()>());
void askFolder(const QString &caption, base::lambda<void(const QString &result)> &&callback, base::lambda<void()> &&failed = base::lambda<void()>()); void askFolder(const QString &caption, base::lambda<void(const QString &result)> callback, base::lambda<void()> failed = base::lambda<void()>());
} // namespace FileDialog } // namespace FileDialog

8
Telegram/SourceFiles/ui/widgets/buttons.cpp
View file

@ -192,9 +192,9 @@ void FlatButton::paintEvent(QPaintEvent *e) {
class RoundButton::Numbers { class RoundButton::Numbers {
public: public:
Numbers(const style::RoundButton &st, base::lambda<void()> &&animationCallback); Numbers(const style::RoundButton &st, base::lambda<void()> animationCallback);
void setWidthChangedCallback(base::lambda<void()> &&callback) { void setWidthChangedCallback(base::lambda<void()> callback) {
_widthChangedCallback = std::move(callback); _widthChangedCallback = std::move(callback);
} }
void setText(const QString &text, int value); void setText(const QString &text, int value);
@ -235,7 +235,7 @@ private:
}; };
RoundButton::Numbers::Numbers(const style::RoundButton &st, base::lambda<void()> &&animationCallback) RoundButton::Numbers::Numbers(const style::RoundButton &st, base::lambda<void()> animationCallback)
: _st(st) : _st(st)
, _animationCallback(std::move(animationCallback)) { , _animationCallback(std::move(animationCallback)) {
for (auto ch = '0'; ch != '9'; ++ch) { for (auto ch = '0'; ch != '9'; ++ch) {
@ -380,7 +380,7 @@ void RoundButton::setNumbersText(const QString &numbersText, int numbers) {
updateText(); updateText();
} }
void RoundButton::setWidthChangedCallback(base::lambda<void()> &&callback) { void RoundButton::setWidthChangedCallback(base::lambda<void()> callback) {
if (!_numbers) { if (!_numbers) {
_numbers = std::make_unique<Numbers>(_st, [this] { numbersAnimationCallback(); }); _numbers = std::make_unique<Numbers>(_st, [this] { numbersAnimationCallback(); });
} }

2
Telegram/SourceFiles/ui/widgets/buttons.h
View file

@ -121,7 +121,7 @@ public:
void setNumbersText(int numbers) { void setNumbersText(int numbers) {
setNumbersText(QString::number(numbers), numbers); setNumbersText(QString::number(numbers), numbers);
} }
void setWidthChangedCallback(base::lambda<void()> &&callback); void setWidthChangedCallback(base::lambda<void()> callback);
void stepNumbersAnimation(TimeMs ms); void stepNumbersAnimation(TimeMs ms);
void finishNumbersAnimation(); void finishNumbersAnimation();

2
Telegram/SourceFiles/ui/widgets/dropdown_menu.cpp
View file

@ -69,7 +69,7 @@ QAction *DropdownMenu::addAction(const QString &text, const QObject *receiver, c
return _menu->addAction(text, receiver, member, icon, iconOver); return _menu->addAction(text, receiver, member, icon, iconOver);
} }
QAction *DropdownMenu::addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon, const style::icon *iconOver) { QAction *DropdownMenu::addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon, const style::icon *iconOver) {
return _menu->addAction(text, std::move(callback), icon, iconOver); return _menu->addAction(text, std::move(callback), icon, iconOver);
} }

4
Telegram/SourceFiles/ui/widgets/dropdown_menu.h
View file

@ -30,11 +30,11 @@ public:
DropdownMenu(QWidget *parent, const style::DropdownMenu &st = st::defaultDropdownMenu); DropdownMenu(QWidget *parent, const style::DropdownMenu &st = st::defaultDropdownMenu);
QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr); QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr); QAction *addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addSeparator(); QAction *addSeparator();
void clearActions(); void clearActions();
void setHiddenCallback(base::lambda<void()> &&callback) { void setHiddenCallback(base::lambda<void()> callback) {
_hiddenCallback = std::move(callback); _hiddenCallback = std::move(callback);
} }

6
Telegram/SourceFiles/ui/widgets/inner_dropdown.h
View file

@ -48,13 +48,13 @@ public:
void otherLeave(); void otherLeave();
void hideFast(); void hideFast();
void setShowStartCallback(base::lambda<void()> &&callback) { void setShowStartCallback(base::lambda<void()> callback) {
_showStartCallback = std::move(callback); _showStartCallback = std::move(callback);
} }
void setHideStartCallback(base::lambda<void()> &&callback) { void setHideStartCallback(base::lambda<void()> callback) {
_hideStartCallback = std::move(callback); _hideStartCallback = std::move(callback);
} }
void setHiddenCallback(base::lambda<void()> &&callback) { void setHiddenCallback(base::lambda<void()> callback) {
_hiddenCallback = std::move(callback); _hiddenCallback = std::move(callback);
} }

2
Telegram/SourceFiles/ui/widgets/menu.cpp
View file

@ -57,7 +57,7 @@ QAction *Menu::addAction(const QString &text, const QObject *receiver, const cha
return action; return action;
} }
QAction *Menu::addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon, const style::icon *iconOver) { QAction *Menu::addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon, const style::icon *iconOver) {
auto action = addAction(new QAction(text, this), icon, iconOver); auto action = addAction(new QAction(text, this), icon, iconOver);
connect(action, SIGNAL(triggered(bool)), base::lambda_slot(action, std::move(callback)), SLOT(action()), Qt::QueuedConnection); connect(action, SIGNAL(triggered(bool)), base::lambda_slot(action, std::move(callback)), SLOT(action()), Qt::QueuedConnection);
return action; return action;

16
Telegram/SourceFiles/ui/widgets/menu.h
View file

@ -34,7 +34,7 @@ public:
Menu(QWidget *parent, QMenu *menu, const style::Menu &st = st::defaultMenu); Menu(QWidget *parent, QMenu *menu, const style::Menu &st = st::defaultMenu);
QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr); QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr); QAction *addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addSeparator(); QAction *addSeparator();
void clearActions(); void clearActions();
@ -52,33 +52,33 @@ public:
using Actions = QList<QAction*>; using Actions = QList<QAction*>;
Actions &actions(); Actions &actions();
void setResizedCallback(base::lambda<void()> &&callback) { void setResizedCallback(base::lambda<void()> callback) {
_resizedCallback = std::move(callback); _resizedCallback = std::move(callback);
} }
void setActivatedCallback(base::lambda<void(QAction *action, int actionTop, TriggeredSource source)> &&callback) { void setActivatedCallback(base::lambda<void(QAction *action, int actionTop, TriggeredSource source)> callback) {
_activatedCallback = std::move(callback); _activatedCallback = std::move(callback);
} }
void setTriggeredCallback(base::lambda<void(QAction *action, int actionTop, TriggeredSource source)> &&callback) { void setTriggeredCallback(base::lambda<void(QAction *action, int actionTop, TriggeredSource source)> callback) {
_triggeredCallback = std::move(callback); _triggeredCallback = std::move(callback);
} }
void setKeyPressDelegate(base::lambda<bool(int key)> &&delegate) { void setKeyPressDelegate(base::lambda<bool(int key)> delegate) {
_keyPressDelegate = std::move(delegate); _keyPressDelegate = std::move(delegate);
} }
void handleKeyPress(int key); void handleKeyPress(int key);
void setMouseMoveDelegate(base::lambda<void(QPoint globalPosition)> &&delegate) { void setMouseMoveDelegate(base::lambda<void(QPoint globalPosition)> delegate) {
_mouseMoveDelegate = std::move(delegate); _mouseMoveDelegate = std::move(delegate);
} }
void handleMouseMove(QPoint globalPosition); void handleMouseMove(QPoint globalPosition);
void setMousePressDelegate(base::lambda<void(QPoint globalPosition)> &&delegate) { void setMousePressDelegate(base::lambda<void(QPoint globalPosition)> delegate) {
_mousePressDelegate = std::move(delegate); _mousePressDelegate = std::move(delegate);
} }
void handleMousePress(QPoint globalPosition); void handleMousePress(QPoint globalPosition);
void setMouseReleaseDelegate(base::lambda<void(QPoint globalPosition)> &&delegate) { void setMouseReleaseDelegate(base::lambda<void(QPoint globalPosition)> delegate) {
_mouseReleaseDelegate = std::move(delegate); _mouseReleaseDelegate = std::move(delegate);
} }
void handleMouseRelease(QPoint globalPosition); void handleMouseRelease(QPoint globalPosition);

26
Telegram/SourceFiles/ui/widgets/multi_select.cpp
View file

@ -57,7 +57,7 @@ public:
void setPosition(int x, int y, int outerWidth, int maxVisiblePadding); void setPosition(int x, int y, int outerWidth, int maxVisiblePadding);
QRect paintArea(int outerWidth) const; QRect paintArea(int outerWidth) const;
void setUpdateCallback(const base::lambda_copy<void()> &updateCallback) { void setUpdateCallback(base::lambda<void()> updateCallback) {
_updateCallback = updateCallback; _updateCallback = updateCallback;
} }
void setText(const QString &text); void setText(const QString &text);
@ -89,7 +89,7 @@ private:
uint64 _id; uint64 _id;
struct SlideAnimation { struct SlideAnimation {
SlideAnimation(const base::lambda_copy<void()> &updateCallback, int fromX, int toX, int y, float64 duration) SlideAnimation(base::lambda<void()> updateCallback, int fromX, int toX, int y, float64 duration)
: fromX(fromX) : fromX(fromX)
, toX(toX) , toX(toX)
, y(y) { , y(y) {
@ -112,7 +112,7 @@ private:
bool _overDelete = false; bool _overDelete = false;
bool _active = false; bool _active = false;
PaintRoundImage _paintRoundImage; PaintRoundImage _paintRoundImage;
base::lambda_copy<void()> _updateCallback; base::lambda<void()> _updateCallback;
bool _hiding = false; bool _hiding = false;
}; };
@ -376,15 +376,15 @@ void MultiSelect::scrollTo(int activeTop, int activeBottom) {
} }
} }
void MultiSelect::setQueryChangedCallback(base::lambda<void(const QString &query)> &&callback) { void MultiSelect::setQueryChangedCallback(base::lambda<void(const QString &query)> callback) {
_queryChangedCallback = std::move(callback); _queryChangedCallback = std::move(callback);
} }
void MultiSelect::setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> &&callback) { void MultiSelect::setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> callback) {
_inner->setSubmittedCallback(std::move(callback)); _inner->setSubmittedCallback(std::move(callback));
} }
void MultiSelect::setResizedCallback(base::lambda<void()> &&callback) { void MultiSelect::setResizedCallback(base::lambda<void()> callback) {
_resizedCallback = std::move(callback); _resizedCallback = std::move(callback);
} }
@ -402,11 +402,11 @@ QString MultiSelect::getQuery() const {
return _inner->getQuery(); return _inner->getQuery();
} }
void MultiSelect::addItem(uint64 itemId, const QString &text, style::color color, PaintRoundImage &&paintRoundImage, AddItemWay way) { void MultiSelect::addItem(uint64 itemId, const QString &text, style::color color, PaintRoundImage paintRoundImage, AddItemWay way) {
_inner->addItem(std::make_unique<Inner::Item>(_st.item, itemId, text, color, std::move(paintRoundImage)), way); _inner->addItem(std::make_unique<Inner::Item>(_st.item, itemId, text, color, std::move(paintRoundImage)), way);
} }
void MultiSelect::setItemRemovedCallback(base::lambda<void(uint64 itemId)> &&callback) { void MultiSelect::setItemRemovedCallback(base::lambda<void(uint64 itemId)> callback) {
_inner->setItemRemovedCallback(std::move(callback)); _inner->setItemRemovedCallback(std::move(callback));
} }
@ -423,7 +423,7 @@ int MultiSelect::resizeGetHeight(int newWidth) {
return newHeight; return newHeight;
} }
MultiSelect::Inner::Inner(QWidget *parent, const style::MultiSelect &st, const QString &placeholder, ScrollCallback &&callback) : TWidget(parent) MultiSelect::Inner::Inner(QWidget *parent, const style::MultiSelect &st, const QString &placeholder, ScrollCallback callback) : TWidget(parent)
, _st(st) , _st(st)
, _scrollCallback(std::move(callback)) , _scrollCallback(std::move(callback))
, _field(this, _st.field, placeholder) , _field(this, _st.field, placeholder)
@ -470,11 +470,11 @@ void MultiSelect::Inner::clearQuery() {
_field->setText(QString()); _field->setText(QString());
} }
void MultiSelect::Inner::setQueryChangedCallback(base::lambda<void(const QString &query)> &&callback) { void MultiSelect::Inner::setQueryChangedCallback(base::lambda<void(const QString &query)> callback) {
_queryChangedCallback = std::move(callback); _queryChangedCallback = std::move(callback);
} }
void MultiSelect::Inner::setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> &&callback) { void MultiSelect::Inner::setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> callback) {
_submittedCallback = std::move(callback); _submittedCallback = std::move(callback);
} }
@ -775,11 +775,11 @@ void MultiSelect::Inner::setItemText(uint64 itemId, const QString &text) {
} }
} }
void MultiSelect::Inner::setItemRemovedCallback(base::lambda<void(uint64 itemId)> &&callback) { void MultiSelect::Inner::setItemRemovedCallback(base::lambda<void(uint64 itemId)> callback) {
_itemRemovedCallback = std::move(callback); _itemRemovedCallback = std::move(callback);
} }
void MultiSelect::Inner::setResizedCallback(base::lambda<void(int heightDelta)> &&callback) { void MultiSelect::Inner::setResizedCallback(base::lambda<void(int heightDelta)> callback) {
_resizedCallback = std::move(callback); _resizedCallback = std::move(callback);
} }

20
Telegram/SourceFiles/ui/widgets/multi_select.h
View file

@ -36,19 +36,19 @@ public:
void setInnerFocus(); void setInnerFocus();
void clearQuery(); void clearQuery();
void setQueryChangedCallback(base::lambda<void(const QString &query)> &&callback); void setQueryChangedCallback(base::lambda<void(const QString &query)> callback);
void setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> &&callback); void setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> callback);
void setResizedCallback(base::lambda<void()> &&callback); void setResizedCallback(base::lambda<void()> callback);
enum class AddItemWay { enum class AddItemWay {
Default, Default,
SkipAnimation, SkipAnimation,
}; };
using PaintRoundImage = base::lambda<void(Painter &p, int x, int y, int outerWidth, int size)>; using PaintRoundImage = base::lambda<void(Painter &p, int x, int y, int outerWidth, int size)>;
void addItem(uint64 itemId, const QString &text, style::color color, PaintRoundImage &&paintRoundImage, AddItemWay way = AddItemWay::Default); void addItem(uint64 itemId, const QString &text, style::color color, PaintRoundImage paintRoundImage, AddItemWay way = AddItemWay::Default);
void setItemText(uint64 itemId, const QString &text); void setItemText(uint64 itemId, const QString &text);
void setItemRemovedCallback(base::lambda<void(uint64 itemId)> &&callback); void setItemRemovedCallback(base::lambda<void(uint64 itemId)> callback);
void removeItem(uint64 itemId); void removeItem(uint64 itemId);
protected: protected:
@ -76,23 +76,23 @@ class MultiSelect::Inner : public TWidget {
public: public:
using ScrollCallback = base::lambda<void(int activeTop, int activeBottom)>; using ScrollCallback = base::lambda<void(int activeTop, int activeBottom)>;
Inner(QWidget *parent, const style::MultiSelect &st, const QString &placeholder, ScrollCallback &&callback); Inner(QWidget *parent, const style::MultiSelect &st, const QString &placeholder, ScrollCallback callback);
QString getQuery() const; QString getQuery() const;
bool setInnerFocus(); bool setInnerFocus();
void clearQuery(); void clearQuery();
void setQueryChangedCallback(base::lambda<void(const QString &query)> &&callback); void setQueryChangedCallback(base::lambda<void(const QString &query)> callback);
void setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> &&callback); void setSubmittedCallback(base::lambda<void(bool ctrlShiftEnter)> callback);
class Item; class Item;
void addItem(std::unique_ptr<Item> item, AddItemWay way); void addItem(std::unique_ptr<Item> item, AddItemWay way);
void setItemText(uint64 itemId, const QString &text); void setItemText(uint64 itemId, const QString &text);
void setItemRemovedCallback(base::lambda<void(uint64 itemId)> &&callback); void setItemRemovedCallback(base::lambda<void(uint64 itemId)> callback);
void removeItem(uint64 itemId); void removeItem(uint64 itemId);
void setResizedCallback(base::lambda<void(int heightDelta)> &&callback); void setResizedCallback(base::lambda<void(int heightDelta)> callback);
~Inner(); ~Inner();

2
Telegram/SourceFiles/ui/widgets/popup_menu.cpp
View file

@ -86,7 +86,7 @@ QAction *PopupMenu::addAction(const QString &text, const QObject *receiver, cons
return _menu->addAction(text, receiver, member, icon, iconOver); return _menu->addAction(text, receiver, member, icon, iconOver);
} }
QAction *PopupMenu::addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon, const style::icon *iconOver) { QAction *PopupMenu::addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon, const style::icon *iconOver) {
return _menu->addAction(text, std::move(callback), icon, iconOver); return _menu->addAction(text, std::move(callback), icon, iconOver);
} }

4
Telegram/SourceFiles/ui/widgets/popup_menu.h
View file

@ -29,7 +29,7 @@ public:
PopupMenu(QWidget*, QMenu *menu, const style::PopupMenu &st = st::defaultPopupMenu); PopupMenu(QWidget*, QMenu *menu, const style::PopupMenu &st = st::defaultPopupMenu);
QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr); QAction *addAction(const QString &text, const QObject *receiver, const char* member, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addAction(const QString &text, base::lambda<void()> &&callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr); QAction *addAction(const QString &text, base::lambda<void()> callback, const style::icon *icon = nullptr, const style::icon *iconOver = nullptr);
QAction *addSeparator(); QAction *addSeparator();
void clearActions(); void clearActions();
@ -40,7 +40,7 @@ public:
void popup(const QPoint &p); void popup(const QPoint &p);
void hideMenu(bool fast = false); void hideMenu(bool fast = false);
void setDestroyedCallback(base::lambda<void()> &&callback) { void setDestroyedCallback(base::lambda<void()> callback) {
_destroyedCallback = std::move(callback); _destroyedCallback = std::move(callback);
} }

2
Telegram/SourceFiles/window/player_wrap_widget.cpp
View file

@ -25,7 +25,7 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
namespace Window { namespace Window {
PlayerWrapWidget::PlayerWrapWidget(QWidget *parent, base::lambda<void()> &&updateCallback) : Parent(parent PlayerWrapWidget::PlayerWrapWidget(QWidget *parent, base::lambda<void()> updateCallback) : Parent(parent
, object_ptr<Media::Player::Widget>(parent) , object_ptr<Media::Player::Widget>(parent)
, style::margins(0, 0, 0, 0) , style::margins(0, 0, 0, 0)
, std::move(updateCallback)) { , std::move(updateCallback)) {

2
Telegram/SourceFiles/window/player_wrap_widget.h
View file

@ -13,7 +13,7 @@ class PlayerWrapWidget : public Ui::WidgetSlideWrap<Media::Player::Widget> {
using Parent = Ui::WidgetSlideWrap<Media::Player::Widget>; using Parent = Ui::WidgetSlideWrap<Media::Player::Widget>;
public: public:
PlayerWrapWidget(QWidget *parent, base::lambda<void()> &&updateCallback); PlayerWrapWidget(QWidget *parent, base::lambda<void()> updateCallback);
void updateAdaptiveLayout() { void updateAdaptiveLayout() {
updateShadowGeometry(); updateShadowGeometry();

2
Telegram/SourceFiles/window/themes/window_theme.cpp
View file

@ -798,7 +798,7 @@ bool CopyColorsToPalette(const QString &path, const QByteArray &themeContent) {
return true; return true;
} }
bool ReadPaletteValues(const QByteArray &content, base::lambda<bool(QLatin1String name, QLatin1String value)> &&callback) { bool ReadPaletteValues(const QByteArray &content, base::lambda<bool(QLatin1String name, QLatin1String value)> callback) {
if (content.size() > kThemeSchemeSizeLimit) { if (content.size() > kThemeSchemeSizeLimit) {
LOG(("Theme Error: color scheme file too large (should be less than 1 MB, got %2)").arg(content.size())); LOG(("Theme Error: color scheme file too large (should be less than 1 MB, got %2)").arg(content.size()));
return false; return false;

2
Telegram/SourceFiles/window/themes/window_theme.h
View file

@ -141,7 +141,7 @@ void ComputeBackgroundRects(QRect wholeFill, QSize imageSize, QRect &to, QRect &
bool CopyColorsToPalette(const QString &path, const QByteArray &themeContent); bool CopyColorsToPalette(const QString &path, const QByteArray &themeContent);
bool ReadPaletteValues(const QByteArray &content, base::lambda<bool(QLatin1String name, QLatin1String value)> &&callback); bool ReadPaletteValues(const QByteArray &content, base::lambda<bool(QLatin1String name, QLatin1String value)> callback);
} // namespace Theme } // namespace Theme
} // namespace Window } // namespace Window

6
Telegram/SourceFiles/window/themes/window_theme_editor.cpp
View file

@ -208,13 +208,13 @@ class Editor::Inner : public TWidget, private base::Subscriber {
public: public:
Inner(QWidget *parent, const QString &path); Inner(QWidget *parent, const QString &path);
void setErrorCallback(base::lambda<void()> &&callback) { void setErrorCallback(base::lambda<void()> callback) {
_errorCallback = std::move(callback); _errorCallback = std::move(callback);
} }
void setFocusCallback(base::lambda<void()> &&callback) { void setFocusCallback(base::lambda<void()> callback) {
_focusCallback = std::move(callback); _focusCallback = std::move(callback);
} }
void setScrollCallback(base::lambda<void(int top, int bottom)> &&callback) { void setScrollCallback(base::lambda<void(int top, int bottom)> callback) {
_scrollCallback = std::move(callback); _scrollCallback = std::move(callback);
} }

2
Telegram/SourceFiles/window/themes/window_theme_warning.h
View file

@ -31,7 +31,7 @@ class WarningWidget : public TWidget {
public: public:
WarningWidget(QWidget *parent); WarningWidget(QWidget *parent);
void setHiddenCallback(base::lambda<void()> &&callback) { void setHiddenCallback(base::lambda<void()> callback) {
_hiddenCallback = std::move(callback); _hiddenCallback = std::move(callback);
} }

2
Telegram/SourceFiles/window/top_bar_widget.cpp
View file

@ -126,7 +126,7 @@ void TopBarWidget::showMenu() {
} }
})); }));
_menuToggle->installEventFilter(_menu); _menuToggle->installEventFilter(_menu);
App::main()->fillPeerMenu(peer, [this](const QString &text, base::lambda<void()> &&callback) { App::main()->fillPeerMenu(peer, [this](const QString &text, base::lambda<void()> callback) {
return _menu->addAction(text, std::move(callback)); return _menu->addAction(text, std::move(callback));
}, false); }, false);
_menu->moveToRight(st::topBarMenuPosition.x(), st::topBarMenuPosition.y()); _menu->moveToRight(st::topBarMenuPosition.x(), st::topBarMenuPosition.y());