From 0b6dea311b890431a6ce227c7bef5a89b5d08cb4 Mon Sep 17 00:00:00 2001 From: John Preston Date: Thu, 24 Mar 2016 23:34:47 +0300 Subject: [PATCH] scheme for new bot keyboards --- Telegram/SourceFiles/app.cpp | 16 ++ Telegram/SourceFiles/mtproto/scheme.tl | 6 +- Telegram/SourceFiles/mtproto/scheme_auto.cpp | 60 ++++- Telegram/SourceFiles/mtproto/scheme_auto.h | 252 +++++++++++++++++-- 4 files changed, 314 insertions(+), 20 deletions(-) diff --git a/Telegram/SourceFiles/app.cpp b/Telegram/SourceFiles/app.cpp index e9d2bbe5c..5c1e17c62 100644 --- a/Telegram/SourceFiles/app.cpp +++ b/Telegram/SourceFiles/app.cpp @@ -2450,6 +2450,22 @@ namespace App { case mtpc_keyboardButton: { btns.push_back(qs(b.at(j).c_keyboardButton().vtext)); } break; + + case mtpc_keyboardButtonCallback: { + + } break; + + case mtpc_keyboardButtonRequestGeoLocation: { + + } break; + + case mtpc_keyboardButtonRequestPhone: { + + } break; + + case mtpc_keyboardButtonUrl: { + + } break; } } if (!btns.isEmpty()) commands.push_back(btns); diff --git a/Telegram/SourceFiles/mtproto/scheme.tl b/Telegram/SourceFiles/mtproto/scheme.tl index e01da730d..120ad0b7f 100644 --- a/Telegram/SourceFiles/mtproto/scheme.tl +++ b/Telegram/SourceFiles/mtproto/scheme.tl @@ -557,12 +557,16 @@ botCommand#c27ac8c7 command:string description:string = BotCommand; botInfo#98e81d3a user_id:int description:string commands:Vector = BotInfo; keyboardButton#a2fa4880 text:string = KeyboardButton; +keyboardButtonUrl#258aff05 text:string url:string = KeyboardButton; +keyboardButtonCallback#2aae4183 text:string = KeyboardButton; +keyboardButtonRequestPhone#b16a6c29 text:string = KeyboardButton; +keyboardButtonRequestGeoLocation#fc796b3f text:string = KeyboardButton; keyboardButtonRow#77608b83 buttons:Vector = KeyboardButtonRow; replyKeyboardHide#a03e5b85 flags:# selective:flags.2?true = ReplyMarkup; replyKeyboardForceReply#f4108aa0 flags:# single_use:flags.1?true selective:flags.2?true = ReplyMarkup; -replyKeyboardMarkup#3502758c flags:# resize:flags.0?true single_use:flags.1?true selective:flags.2?true rows:Vector = ReplyMarkup; +replyKeyboardMarkup#3502758c flags:# resize:flags.0?true single_use:flags.1?true selective:flags.2?true inline:flags.3?true rows:Vector = ReplyMarkup; help.appChangelogEmpty#af7e0394 = help.AppChangelog; help.appChangelog#4668e6bd text:string = help.AppChangelog; diff --git a/Telegram/SourceFiles/mtproto/scheme_auto.cpp b/Telegram/SourceFiles/mtproto/scheme_auto.cpp index 272945bd8..1fe0a87a4 100644 --- a/Telegram/SourceFiles/mtproto/scheme_auto.cpp +++ b/Telegram/SourceFiles/mtproto/scheme_auto.cpp @@ -4391,6 +4391,59 @@ void _serialize_keyboardButton(MTPStringLogger &to, int32 stage, int32 lev, Type } } +void _serialize_keyboardButtonUrl(MTPStringLogger &to, int32 stage, int32 lev, Types &types, Types &vtypes, StagesFlags &stages, StagesFlags &flags, const mtpPrime *start, const mtpPrime *end, int32 iflag) { + if (stage) { + to.add(",\n").addSpaces(lev); + } else { + to.add("{ keyboardButtonUrl"); + to.add("\n").addSpaces(lev); + } + switch (stage) { + case 0: to.add(" text: "); ++stages.back(); types.push_back(mtpc_string+0); vtypes.push_back(0); stages.push_back(0); flags.push_back(0); break; + case 1: to.add(" url: "); ++stages.back(); types.push_back(mtpc_string+0); vtypes.push_back(0); stages.push_back(0); flags.push_back(0); break; + default: to.add("}"); types.pop_back(); vtypes.pop_back(); stages.pop_back(); flags.pop_back(); break; + } +} + +void _serialize_keyboardButtonCallback(MTPStringLogger &to, int32 stage, int32 lev, Types &types, Types &vtypes, StagesFlags &stages, StagesFlags &flags, const mtpPrime *start, const mtpPrime *end, int32 iflag) { + if (stage) { + to.add(",\n").addSpaces(lev); + } else { + to.add("{ keyboardButtonCallback"); + to.add("\n").addSpaces(lev); + } + switch (stage) { + case 0: to.add(" text: "); ++stages.back(); types.push_back(mtpc_string+0); vtypes.push_back(0); stages.push_back(0); flags.push_back(0); break; + default: to.add("}"); types.pop_back(); vtypes.pop_back(); stages.pop_back(); flags.pop_back(); break; + } +} + +void _serialize_keyboardButtonRequestPhone(MTPStringLogger &to, int32 stage, int32 lev, Types &types, Types &vtypes, StagesFlags &stages, StagesFlags &flags, const mtpPrime *start, const mtpPrime *end, int32 iflag) { + if (stage) { + to.add(",\n").addSpaces(lev); + } else { + to.add("{ keyboardButtonRequestPhone"); + to.add("\n").addSpaces(lev); + } + switch (stage) { + case 0: to.add(" text: "); ++stages.back(); types.push_back(mtpc_string+0); vtypes.push_back(0); stages.push_back(0); flags.push_back(0); break; + default: to.add("}"); types.pop_back(); vtypes.pop_back(); stages.pop_back(); flags.pop_back(); break; + } +} + +void _serialize_keyboardButtonRequestGeoLocation(MTPStringLogger &to, int32 stage, int32 lev, Types &types, Types &vtypes, StagesFlags &stages, StagesFlags &flags, const mtpPrime *start, const mtpPrime *end, int32 iflag) { + if (stage) { + to.add(",\n").addSpaces(lev); + } else { + to.add("{ keyboardButtonRequestGeoLocation"); + to.add("\n").addSpaces(lev); + } + switch (stage) { + case 0: to.add(" text: "); ++stages.back(); types.push_back(mtpc_string+0); vtypes.push_back(0); stages.push_back(0); flags.push_back(0); break; + default: to.add("}"); types.pop_back(); vtypes.pop_back(); stages.pop_back(); flags.pop_back(); break; + } +} + void _serialize_keyboardButtonRow(MTPStringLogger &to, int32 stage, int32 lev, Types &types, Types &vtypes, StagesFlags &stages, StagesFlags &flags, const mtpPrime *start, const mtpPrime *end, int32 iflag) { if (stage) { to.add(",\n").addSpaces(lev); @@ -4451,7 +4504,8 @@ void _serialize_replyKeyboardMarkup(MTPStringLogger &to, int32 stage, int32 lev, case 1: to.add(" resize: "); ++stages.back(); if (flag & MTPDreplyKeyboardMarkup::Flag::f_resize) { to.add("YES [ BY BIT 0 IN FIELD flags ]"); } else { to.add("[ SKIPPED BY BIT 0 IN FIELD flags ]"); } break; case 2: to.add(" single_use: "); ++stages.back(); if (flag & MTPDreplyKeyboardMarkup::Flag::f_single_use) { to.add("YES [ BY BIT 1 IN FIELD flags ]"); } else { to.add("[ SKIPPED BY BIT 1 IN FIELD flags ]"); } break; case 3: to.add(" selective: "); ++stages.back(); if (flag & MTPDreplyKeyboardMarkup::Flag::f_selective) { to.add("YES [ BY BIT 2 IN FIELD flags ]"); } else { to.add("[ SKIPPED BY BIT 2 IN FIELD flags ]"); } break; - case 4: to.add(" rows: "); ++stages.back(); types.push_back(00); vtypes.push_back(0); stages.push_back(0); flags.push_back(0); break; + case 4: to.add(" inline: "); ++stages.back(); if (flag & MTPDreplyKeyboardMarkup::Flag::f_inline) { to.add("YES [ BY BIT 3 IN FIELD flags ]"); } else { to.add("[ SKIPPED BY BIT 3 IN FIELD flags ]"); } break; + case 5: to.add(" rows: "); ++stages.back(); types.push_back(00); vtypes.push_back(0); stages.push_back(0); flags.push_back(0); break; default: to.add("}"); types.pop_back(); vtypes.pop_back(); stages.pop_back(); flags.pop_back(); break; } } @@ -8097,6 +8151,10 @@ namespace { _serializers.insert(mtpc_botCommand, _serialize_botCommand); _serializers.insert(mtpc_botInfo, _serialize_botInfo); _serializers.insert(mtpc_keyboardButton, _serialize_keyboardButton); + _serializers.insert(mtpc_keyboardButtonUrl, _serialize_keyboardButtonUrl); + _serializers.insert(mtpc_keyboardButtonCallback, _serialize_keyboardButtonCallback); + _serializers.insert(mtpc_keyboardButtonRequestPhone, _serialize_keyboardButtonRequestPhone); + _serializers.insert(mtpc_keyboardButtonRequestGeoLocation, _serialize_keyboardButtonRequestGeoLocation); _serializers.insert(mtpc_keyboardButtonRow, _serialize_keyboardButtonRow); _serializers.insert(mtpc_replyKeyboardHide, _serialize_replyKeyboardHide); _serializers.insert(mtpc_replyKeyboardForceReply, _serialize_replyKeyboardForceReply); diff --git a/Telegram/SourceFiles/mtproto/scheme_auto.h b/Telegram/SourceFiles/mtproto/scheme_auto.h index 69f6e3311..00a5ab2a6 100644 --- a/Telegram/SourceFiles/mtproto/scheme_auto.h +++ b/Telegram/SourceFiles/mtproto/scheme_auto.h @@ -398,6 +398,10 @@ enum { mtpc_botCommand = 0xc27ac8c7, mtpc_botInfo = 0x98e81d3a, mtpc_keyboardButton = 0xa2fa4880, + mtpc_keyboardButtonUrl = 0x258aff05, + mtpc_keyboardButtonCallback = 0x2aae4183, + mtpc_keyboardButtonRequestPhone = 0xb16a6c29, + mtpc_keyboardButtonRequestGeoLocation = 0xfc796b3f, mtpc_keyboardButtonRow = 0x77608b83, mtpc_replyKeyboardHide = 0xa03e5b85, mtpc_replyKeyboardForceReply = 0xf4108aa0, @@ -1160,6 +1164,10 @@ class MTPDbotInfo; class MTPkeyboardButton; class MTPDkeyboardButton; +class MTPDkeyboardButtonUrl; +class MTPDkeyboardButtonCallback; +class MTPDkeyboardButtonRequestPhone; +class MTPDkeyboardButtonRequestGeoLocation; class MTPkeyboardButtonRow; class MTPDkeyboardButtonRow; @@ -7614,32 +7622,90 @@ typedef MTPBoxed MTPBotInfo; class MTPkeyboardButton : private mtpDataOwner { public: - MTPkeyboardButton(); - MTPkeyboardButton(const mtpPrime *&from, const mtpPrime *end, mtpTypeId cons = mtpc_keyboardButton) : mtpDataOwner(0) { + MTPkeyboardButton() : mtpDataOwner(0), _type(0) { + } + MTPkeyboardButton(const mtpPrime *&from, const mtpPrime *end, mtpTypeId cons) : mtpDataOwner(0), _type(0) { read(from, end, cons); } MTPDkeyboardButton &_keyboardButton() { if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButton) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButton); split(); return *(MTPDkeyboardButton*)data; } const MTPDkeyboardButton &c_keyboardButton() const { if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButton) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButton); return *(const MTPDkeyboardButton*)data; } + MTPDkeyboardButtonUrl &_keyboardButtonUrl() { + if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButtonUrl) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButtonUrl); + split(); + return *(MTPDkeyboardButtonUrl*)data; + } + const MTPDkeyboardButtonUrl &c_keyboardButtonUrl() const { + if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButtonUrl) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButtonUrl); + return *(const MTPDkeyboardButtonUrl*)data; + } + + MTPDkeyboardButtonCallback &_keyboardButtonCallback() { + if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButtonCallback) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButtonCallback); + split(); + return *(MTPDkeyboardButtonCallback*)data; + } + const MTPDkeyboardButtonCallback &c_keyboardButtonCallback() const { + if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButtonCallback) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButtonCallback); + return *(const MTPDkeyboardButtonCallback*)data; + } + + MTPDkeyboardButtonRequestPhone &_keyboardButtonRequestPhone() { + if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButtonRequestPhone) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButtonRequestPhone); + split(); + return *(MTPDkeyboardButtonRequestPhone*)data; + } + const MTPDkeyboardButtonRequestPhone &c_keyboardButtonRequestPhone() const { + if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButtonRequestPhone) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButtonRequestPhone); + return *(const MTPDkeyboardButtonRequestPhone*)data; + } + + MTPDkeyboardButtonRequestGeoLocation &_keyboardButtonRequestGeoLocation() { + if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButtonRequestGeoLocation) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButtonRequestGeoLocation); + split(); + return *(MTPDkeyboardButtonRequestGeoLocation*)data; + } + const MTPDkeyboardButtonRequestGeoLocation &c_keyboardButtonRequestGeoLocation() const { + if (!data) throw mtpErrorUninitialized(); + if (_type != mtpc_keyboardButtonRequestGeoLocation) throw mtpErrorWrongTypeId(_type, mtpc_keyboardButtonRequestGeoLocation); + return *(const MTPDkeyboardButtonRequestGeoLocation*)data; + } + uint32 innerLength() const; mtpTypeId type() const; - void read(const mtpPrime *&from, const mtpPrime *end, mtpTypeId cons = mtpc_keyboardButton); + void read(const mtpPrime *&from, const mtpPrime *end, mtpTypeId cons); void write(mtpBuffer &to) const; typedef void ResponseType; private: + explicit MTPkeyboardButton(mtpTypeId type); explicit MTPkeyboardButton(MTPDkeyboardButton *_data); + explicit MTPkeyboardButton(MTPDkeyboardButtonUrl *_data); + explicit MTPkeyboardButton(MTPDkeyboardButtonCallback *_data); + explicit MTPkeyboardButton(MTPDkeyboardButtonRequestPhone *_data); + explicit MTPkeyboardButton(MTPDkeyboardButtonRequestGeoLocation *_data); friend class MTP::internal::TypeCreator; + + mtpTypeId _type; }; typedef MTPBoxed MTPKeyboardButton; @@ -12503,6 +12569,47 @@ public: MTPstring vtext; }; +class MTPDkeyboardButtonUrl : public mtpDataImpl { +public: + MTPDkeyboardButtonUrl() { + } + MTPDkeyboardButtonUrl(const MTPstring &_text, const MTPstring &_url) : vtext(_text), vurl(_url) { + } + + MTPstring vtext; + MTPstring vurl; +}; + +class MTPDkeyboardButtonCallback : public mtpDataImpl { +public: + MTPDkeyboardButtonCallback() { + } + MTPDkeyboardButtonCallback(const MTPstring &_text) : vtext(_text) { + } + + MTPstring vtext; +}; + +class MTPDkeyboardButtonRequestPhone : public mtpDataImpl { +public: + MTPDkeyboardButtonRequestPhone() { + } + MTPDkeyboardButtonRequestPhone(const MTPstring &_text) : vtext(_text) { + } + + MTPstring vtext; +}; + +class MTPDkeyboardButtonRequestGeoLocation : public mtpDataImpl { +public: + MTPDkeyboardButtonRequestGeoLocation() { + } + MTPDkeyboardButtonRequestGeoLocation(const MTPstring &_text) : vtext(_text) { + } + + MTPstring vtext; +}; + class MTPDkeyboardButtonRow : public mtpDataImpl { public: MTPDkeyboardButtonRow() { @@ -12561,8 +12668,9 @@ public: f_resize = (1 << 0), f_single_use = (1 << 1), f_selective = (1 << 2), + f_inline = (1 << 3), - MAX_FIELD = (1 << 2), + MAX_FIELD = (1 << 3), }; Q_DECLARE_FLAGS(Flags, Flag); friend inline Flags operator~(Flag v) { return QFlag(~static_cast(v)); } @@ -12570,6 +12678,7 @@ public: bool is_resize() const { return vflags.v & Flag::f_resize; } bool is_single_use() const { return vflags.v & Flag::f_single_use; } bool is_selective() const { return vflags.v & Flag::f_selective; } + bool is_inline() const { return vflags.v & Flag::f_inline; } MTPDreplyKeyboardMarkup() { } @@ -21936,6 +22045,18 @@ public: inline static MTPkeyboardButton new_keyboardButton(const MTPstring &_text) { return MTPkeyboardButton(new MTPDkeyboardButton(_text)); } + inline static MTPkeyboardButton new_keyboardButtonUrl(const MTPstring &_text, const MTPstring &_url) { + return MTPkeyboardButton(new MTPDkeyboardButtonUrl(_text, _url)); + } + inline static MTPkeyboardButton new_keyboardButtonCallback(const MTPstring &_text) { + return MTPkeyboardButton(new MTPDkeyboardButtonCallback(_text)); + } + inline static MTPkeyboardButton new_keyboardButtonRequestPhone(const MTPstring &_text) { + return MTPkeyboardButton(new MTPDkeyboardButtonRequestPhone(_text)); + } + inline static MTPkeyboardButton new_keyboardButtonRequestGeoLocation(const MTPstring &_text) { + return MTPkeyboardButton(new MTPDkeyboardButtonRequestGeoLocation(_text)); + } inline static MTPkeyboardButtonRow new_keyboardButtonRow(const MTPVector &_buttons) { return MTPkeyboardButtonRow(new MTPDkeyboardButtonRow(_buttons)); } @@ -30840,32 +30961,127 @@ inline MTPbotInfo MTP_botInfo(MTPint _user_id, const MTPstring &_description, co return MTP::internal::TypeCreator::new_botInfo(_user_id, _description, _commands); } -inline MTPkeyboardButton::MTPkeyboardButton() : mtpDataOwner(new MTPDkeyboardButton()) { -} - inline uint32 MTPkeyboardButton::innerLength() const { - const MTPDkeyboardButton &v(c_keyboardButton()); - return v.vtext.innerLength(); + switch (_type) { + case mtpc_keyboardButton: { + const MTPDkeyboardButton &v(c_keyboardButton()); + return v.vtext.innerLength(); + } + case mtpc_keyboardButtonUrl: { + const MTPDkeyboardButtonUrl &v(c_keyboardButtonUrl()); + return v.vtext.innerLength() + v.vurl.innerLength(); + } + case mtpc_keyboardButtonCallback: { + const MTPDkeyboardButtonCallback &v(c_keyboardButtonCallback()); + return v.vtext.innerLength(); + } + case mtpc_keyboardButtonRequestPhone: { + const MTPDkeyboardButtonRequestPhone &v(c_keyboardButtonRequestPhone()); + return v.vtext.innerLength(); + } + case mtpc_keyboardButtonRequestGeoLocation: { + const MTPDkeyboardButtonRequestGeoLocation &v(c_keyboardButtonRequestGeoLocation()); + return v.vtext.innerLength(); + } + } + return 0; } inline mtpTypeId MTPkeyboardButton::type() const { - return mtpc_keyboardButton; + if (!_type) throw mtpErrorUninitialized(); + return _type; } inline void MTPkeyboardButton::read(const mtpPrime *&from, const mtpPrime *end, mtpTypeId cons) { - if (cons != mtpc_keyboardButton) throw mtpErrorUnexpected(cons, "MTPkeyboardButton"); - - if (!data) setData(new MTPDkeyboardButton()); - MTPDkeyboardButton &v(_keyboardButton()); - v.vtext.read(from, end); + if (cons != _type) setData(0); + switch (cons) { + case mtpc_keyboardButton: _type = cons; { + if (!data) setData(new MTPDkeyboardButton()); + MTPDkeyboardButton &v(_keyboardButton()); + v.vtext.read(from, end); + } break; + case mtpc_keyboardButtonUrl: _type = cons; { + if (!data) setData(new MTPDkeyboardButtonUrl()); + MTPDkeyboardButtonUrl &v(_keyboardButtonUrl()); + v.vtext.read(from, end); + v.vurl.read(from, end); + } break; + case mtpc_keyboardButtonCallback: _type = cons; { + if (!data) setData(new MTPDkeyboardButtonCallback()); + MTPDkeyboardButtonCallback &v(_keyboardButtonCallback()); + v.vtext.read(from, end); + } break; + case mtpc_keyboardButtonRequestPhone: _type = cons; { + if (!data) setData(new MTPDkeyboardButtonRequestPhone()); + MTPDkeyboardButtonRequestPhone &v(_keyboardButtonRequestPhone()); + v.vtext.read(from, end); + } break; + case mtpc_keyboardButtonRequestGeoLocation: _type = cons; { + if (!data) setData(new MTPDkeyboardButtonRequestGeoLocation()); + MTPDkeyboardButtonRequestGeoLocation &v(_keyboardButtonRequestGeoLocation()); + v.vtext.read(from, end); + } break; + default: throw mtpErrorUnexpected(cons, "MTPkeyboardButton"); + } } inline void MTPkeyboardButton::write(mtpBuffer &to) const { - const MTPDkeyboardButton &v(c_keyboardButton()); - v.vtext.write(to); + switch (_type) { + case mtpc_keyboardButton: { + const MTPDkeyboardButton &v(c_keyboardButton()); + v.vtext.write(to); + } break; + case mtpc_keyboardButtonUrl: { + const MTPDkeyboardButtonUrl &v(c_keyboardButtonUrl()); + v.vtext.write(to); + v.vurl.write(to); + } break; + case mtpc_keyboardButtonCallback: { + const MTPDkeyboardButtonCallback &v(c_keyboardButtonCallback()); + v.vtext.write(to); + } break; + case mtpc_keyboardButtonRequestPhone: { + const MTPDkeyboardButtonRequestPhone &v(c_keyboardButtonRequestPhone()); + v.vtext.write(to); + } break; + case mtpc_keyboardButtonRequestGeoLocation: { + const MTPDkeyboardButtonRequestGeoLocation &v(c_keyboardButtonRequestGeoLocation()); + v.vtext.write(to); + } break; + } } -inline MTPkeyboardButton::MTPkeyboardButton(MTPDkeyboardButton *_data) : mtpDataOwner(_data) { +inline MTPkeyboardButton::MTPkeyboardButton(mtpTypeId type) : mtpDataOwner(0), _type(type) { + switch (type) { + case mtpc_keyboardButton: setData(new MTPDkeyboardButton()); break; + case mtpc_keyboardButtonUrl: setData(new MTPDkeyboardButtonUrl()); break; + case mtpc_keyboardButtonCallback: setData(new MTPDkeyboardButtonCallback()); break; + case mtpc_keyboardButtonRequestPhone: setData(new MTPDkeyboardButtonRequestPhone()); break; + case mtpc_keyboardButtonRequestGeoLocation: setData(new MTPDkeyboardButtonRequestGeoLocation()); break; + default: throw mtpErrorBadTypeId(type, "MTPkeyboardButton"); + } +} +inline MTPkeyboardButton::MTPkeyboardButton(MTPDkeyboardButton *_data) : mtpDataOwner(_data), _type(mtpc_keyboardButton) { +} +inline MTPkeyboardButton::MTPkeyboardButton(MTPDkeyboardButtonUrl *_data) : mtpDataOwner(_data), _type(mtpc_keyboardButtonUrl) { +} +inline MTPkeyboardButton::MTPkeyboardButton(MTPDkeyboardButtonCallback *_data) : mtpDataOwner(_data), _type(mtpc_keyboardButtonCallback) { +} +inline MTPkeyboardButton::MTPkeyboardButton(MTPDkeyboardButtonRequestPhone *_data) : mtpDataOwner(_data), _type(mtpc_keyboardButtonRequestPhone) { +} +inline MTPkeyboardButton::MTPkeyboardButton(MTPDkeyboardButtonRequestGeoLocation *_data) : mtpDataOwner(_data), _type(mtpc_keyboardButtonRequestGeoLocation) { } inline MTPkeyboardButton MTP_keyboardButton(const MTPstring &_text) { return MTP::internal::TypeCreator::new_keyboardButton(_text); } +inline MTPkeyboardButton MTP_keyboardButtonUrl(const MTPstring &_text, const MTPstring &_url) { + return MTP::internal::TypeCreator::new_keyboardButtonUrl(_text, _url); +} +inline MTPkeyboardButton MTP_keyboardButtonCallback(const MTPstring &_text) { + return MTP::internal::TypeCreator::new_keyboardButtonCallback(_text); +} +inline MTPkeyboardButton MTP_keyboardButtonRequestPhone(const MTPstring &_text) { + return MTP::internal::TypeCreator::new_keyboardButtonRequestPhone(_text); +} +inline MTPkeyboardButton MTP_keyboardButtonRequestGeoLocation(const MTPstring &_text) { + return MTP::internal::TypeCreator::new_keyboardButtonRequestGeoLocation(_text); +} inline MTPkeyboardButtonRow::MTPkeyboardButtonRow() : mtpDataOwner(new MTPDkeyboardButtonRow()) { }