Merge pull request #13 from MajMcCloud/development

Development

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: #[MajMcCloud]
+custom: ["https://paypal.me/majmccloud", dahn.partners]

Examples/AsyncFormUpdates/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+    </startup>
+</configuration>

Examples/AsyncFormUpdates/AsyncFormUpdates.csproj

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{673A56F5-6110-4AED-A68D-562FD6ED3EA6}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <RootNamespace>AsyncFormUpdates</RootNamespace>
+    <AssemblyName>AsyncFormUpdates</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=11.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Newtonsoft.Json.11.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+    <Reference Include="Telegram.Bot, Version=15.7.1.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Telegram.Bot.15.7.1\lib\net45\Telegram.Bot.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="forms\AsyncFormEdit.cs" />
+    <Compile Include="forms\AsyncFormUpdate.cs" />
+    <Compile Include="forms\Start.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\TelegramBotBase\TelegramBotBase.csproj">
+      <Project>{0bd16fb9-7ed4-4ccb-83eb-5cee538e1b6c}</Project>
+      <Name>TelegramBotBase</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

Examples/AsyncFormUpdates/Program.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Timers;
+
+namespace AsyncFormUpdates
+{
+    class Program
+    {
+        static TelegramBotBase.BotBase<forms.Start> bot = null;
+
+        static void Main(string[] args)
+        {
+            String apiKey = "APIKey";
+
+            bot = new TelegramBotBase.BotBase<forms.Start>(apiKey);
+
+            bot.Start();
+
+            var timer = new Timer(5000);
+
+            timer.Elapsed += Timer_Elapsed;
+            timer.Start();
+
+            Console.ReadLine();
+
+            timer.Stop();
+            bot.Stop();
+        }
+
+        private static async void Timer_Elapsed(object sender, ElapsedEventArgs e)
+        {
+            
+            foreach(var s in bot.Sessions.SessionList)
+            {
+                //Only for AsyncUpdateForm
+                if (s.Value.ActiveForm.GetType() != typeof(forms.AsyncFormUpdate) && s.Value.ActiveForm.GetType() != typeof(forms.AsyncFormEdit))
+                    continue;
+
+                await bot.InvokeMessageLoop(s.Key);
+            }
+
+
+        }
+    }
+}

Examples/AsyncFormUpdates/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Allgemeine Informationen über eine Assembly werden über die folgenden
+// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
+// die einer Assembly zugeordnet sind.
+[assembly: AssemblyTitle("AsyncFormUpdates")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("AsyncFormUpdates")]
+[assembly: AssemblyCopyright("Copyright ©  2021")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Durch Festlegen von ComVisible auf FALSE werden die Typen in dieser Assembly
+// für COM-Komponenten unsichtbar.  Wenn Sie auf einen Typ in dieser Assembly von
+// COM aus zugreifen müssen, sollten Sie das ComVisible-Attribut für diesen Typ auf "True" festlegen.
+[assembly: ComVisible(false)]
+
+// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
+[assembly: Guid("673a56f5-6110-4aed-a68d-562fd6ed3ea6")]
+
+// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
+//
+//      Hauptversion
+//      Nebenversion
+//      Buildnummer
+//      Revision
+//
+// Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden,
+// indem Sie "*" wie unten gezeigt eingeben:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Examples/AsyncFormUpdates/forms/AsyncFormEdit.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Attributes;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace AsyncFormUpdates.forms
+{
+    public class AsyncFormEdit : FormBase
+    {
+        [SaveState]
+        int counter = 0;
+
+        int MessageId = 0;
+
+        public override async Task Load(MessageResult message)
+        {
+            counter++;
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            await message.ConfirmAction("");
+
+            switch (message.RawData ?? "")
+            {
+                case "back":
+
+                    var st = new Start();
+                    await NavigateTo(st);
+
+                    break;
+            }
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            var bf = new ButtonForm();
+            bf.AddButtonRow("Back", "back");
+
+            if (MessageId != 0)
+            {
+                await Device.Edit(MessageId, $"Your current count is at: {counter}", bf);
+            }
+            else
+            {
+                var m = await Device.Send($"Your current count is at: {counter}", bf, disableNotification: true);
+                MessageId = m.MessageId;
+            }
+
+        }
+
+    }
+}

Examples/AsyncFormUpdates/forms/AsyncFormUpdate.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Attributes;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace AsyncFormUpdates.forms
+{
+    public class AsyncFormUpdate : AutoCleanForm
+    {
+        [SaveState]
+        int counter = 0;
+
+
+        public override async Task Load(MessageResult message)
+        {
+            counter++;
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            await message.ConfirmAction("");
+
+            switch (message.RawData ?? "")
+            {
+                case "back":
+
+                    var st = new Start();
+                    await NavigateTo(st);
+
+                    break;
+            }
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            var bf = new ButtonForm();
+            bf.AddButtonRow("Back", "back");
+
+            await Device.Send($"Your current count is at: {counter}", bf, disableNotification: true);
+        }
+
+
+    }
+}

Examples/AsyncFormUpdates/forms/Start.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace AsyncFormUpdates.forms
+{
+    public class Start : AutoCleanForm
+    {
+
+
+        public override async Task Action(MessageResult message)
+        {
+            await message.ConfirmAction("");
+
+            switch (message.RawData ?? "")
+            {
+                case "async":
+
+                    var afe = new AsyncFormEdit();
+                    await NavigateTo(afe);
+
+
+                    break;
+
+                case "async_del":
+
+                    var afu = new AsyncFormUpdate();
+                    await NavigateTo(afu);
+
+
+                    break;
+            }
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            var bf = new ButtonForm();
+
+            bf.AddButtonRow("Open Async Form with AutoCleanupForm", "async_del");
+
+            bf.AddButtonRow("Open Async Form with Edit", "async");
+
+            await Device.Send("Choose your option", bf);
+        }
+
+    }
+}

Examples/AsyncFormUpdates/packages.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Newtonsoft.Json" version="11.0.2" targetFramework="net472" />
+  <package id="System.Net.Requests" version="4.3.0" targetFramework="net472" />
+  <package id="Telegram.Bot" version="15.7.1" targetFramework="net472" />
+</packages>

Examples/JoinHiderBot/JoinHiderBot.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="TelegramBotBase" Version="3.1.1" />
+  </ItemGroup>
+
+</Project>

Examples/JoinHiderBot/Program.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace JoinHiderBot
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+
+            String apiKey = "";
+
+            var bot = new TelegramBotBase.BotBase<forms.Start>(apiKey);
+
+            bot.Start();
+
+            Console.ReadLine();
+        }
+    }
+}

Examples/JoinHiderBot/forms/GroupManageForm.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Args;
+using TelegramBotBase.Form;
+
+namespace JoinHiderBot.forms
+{
+    public class GroupManageForm : GroupForm
+    {
+
+        public override async Task OnMemberChanges(MemberChangeEventArgs e)
+        {
+            if (e.Type != Telegram.Bot.Types.Enums.MessageType.ChatMembersAdded && e.Type != Telegram.Bot.Types.Enums.MessageType.ChatMemberLeft)
+                return;
+
+
+            var m = e.Result.Message;
+
+            await this.Device.DeleteMessage(m);
+        }
+
+    }
+}

Examples/JoinHiderBot/forms/Start.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace JoinHiderBot.forms
+{
+    public class Start :  SplitterForm
+    {
+        public override async Task<bool> Open(MessageResult e)
+        {
+            await this.Device.Send("This bot works only in groups.");
+
+            return true;
+        }
+
+        public override async Task<bool> OpenGroup(MessageResult e)
+        {
+            var gmf = new GroupManageForm();
+
+            await this.NavigateTo(gmf);
+
+            return true;
+        }
+
+    }
+}

Examples/SystemCommandsBot/Program.cs

@@ -0,0 +1,36 @@
+using System;
+
+namespace SystemCommandsBot
+{
+    class Program
+    {
+        public static config.Config BotConfig { get; set; }
+
+
+        static void Main(string[] args)
+        {
+
+            BotConfig = config.Config.load();
+
+            if (BotConfig.ApiKey == null || BotConfig.ApiKey.Trim() == "")
+            {
+                Console.WriteLine("Config created...");
+                Console.ReadLine();
+                return;
+            }
+
+            var bot = new TelegramBotBase.BotBase<forms.StartForm>(BotConfig.ApiKey);
+
+            bot.Start();
+
+            Console.WriteLine("Bot started");
+
+            Console.ReadLine();
+
+
+            bot.Stop();
+
+
+        }
+    }
+}

Examples/SystemCommandsBot/SystemCommandsBot.csproj

@@ -7,10 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-  </ItemGroup>
+    <PackageReference Include="TelegramBotBase" Version="3.1.1" />
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\TelegramBotBase\TelegramBotBase.csproj" />
   </ItemGroup>
 
 </Project>

README.md

@@ -70,16 +70,53 @@ Thanks !
 	* [ToggleButton](#toggle-button)
 
 	* [ButtonGrid](#button-grid)
+	
+		* [Paging and Searching](#paging--searching)
+
+    * [TaggedButtonGrid](#tagged-button-grid)
+
+    * [CheckedButtonList](#checked-button-list)
+
+    * [MultiToggleButton](#multi-toggle-button)
 
 - [Groups](#groups)
 	* [SplitterForm](#splitter-form)
 
-	* [GroupForm](#group-form)
+    * [GroupForm](#group-form)
 
-- [State Machine and Session Serialization](#statemachine)
+- [State Machine and Session Serialization (v3.0.0)](#statemachine-and-sessions)
 
-    * In the making, is comming soon.
+    * [StateMachines](#statemachines)
+    
+        * [SimpleJSONStateMachine](#simplejsonstatemachine)
+	
+        * [JSONStateMachine](#jsonstatemachine)
+	
+        * [XMLStateMachine](#xmlstatemachine)
 
+    * [Interfaces](#interfaces)
+    
+        * [IStateMachine](#istatemachine)
+	
+        * [IStateForm](#istateform)
+
+    * [Attributes](#attributes)
+
+        * [SaveState](#savestate)
+	
+        * [IgnoreState](#ignorestate)
+	
+
+- [Navigation and NavigationController (v4.0.0)](#navigation-and-navigationcontroller)
+
+    * [As of Now](#as-of-now)
+
+    * [How to use](#how-to-use-)
+
+
+
+
+- [Examples](#examples)
 
 ---
 
@@ -99,7 +136,7 @@ It gives you features which will look/feel like WinForms or have a good way to c
 ## How to start:
 
 Within your empty App your need to put some initial lines including your APIKey to get things started. 
-The "BotBase" Class will manage a lot of things for you, like system calls, action events and so on. 
+The "BotBase" Class will manage a lot of things for you, like bot commands, action events and so on. 
 "StartForm" is your first Formular which every user will get internally redirected to, like a start page, you could redirect from there later in code, so users won't recognize it. 
 It needs to be a subclass of "FormBase" you will find in Namespace TelegramBotBase.Base
 
@@ -110,7 +147,10 @@ It needs to be a subclass of "FormBase" you will find in Namespace TelegramBotBa
 BotBase<StartForm> bb = new BotBase<StartForm>("{YOUR API KEY}");
 
 //Add Systemcommands if you like, you could catch them later
-bb.SystemCalls.Add("/start");
+bb.BotCommands.Add(new BotCommand() { Command = "start", Description = "Starts the bot" });
+
+//Update bot commands to botfather
+bb.UploadBotCommands().Wait();
 
 //Start your Bot
 bb.Start();
@@ -135,23 +175,22 @@ public class StartForm : FormBase
             
         }
 		
-	//Gets invoked if the form gets opened (with Form.NavigateTo(NewForm))
+    	//Opened() got replaced with event handler
-        public override async Task Opened()
-        {
 
-        }
+    	//Closed() got replaced with event handler
-		
-	//Gets invoked if the form gets leaved
-        public override async Task Closed()
-        {
 
-        }
 		
 	//Gets invoked on every Message/Action/Data in this context
         public override async Task Load(MessageResult message)
         {
             await this.Device.Send("Hello world!");
         }
+	
+	//Gets invoked on edited messages
+	public override async Task Edited(MessageResult message)
+        {
+            
+        }
 		
 	//Gets invoked on Button clicks
         public override async Task Action(MessageResult message)
@@ -196,10 +235,10 @@ await this.NavigateTo(tf);
 
 All examples are within the test project, so just try it out on your own.
 
-### Add some system calls (Example #0 - System Calls)
+### Add some system calls (Example #0 - Bot Commands)
 
 Inside of the BotFather you are able to add "Commands" to your TelegramBot. The user will see them, depending on the application as options he could choose.
-I'm calling them Systemcalls. Before start (and later for sure) you could add them to your BotBase. Every time a message comes in they will get checked if they are one of them.
+Before start (and later for sure) you could add them to your BotBase. Every time a message comes in they will get checked if they are one of them.
 If so, a special event Handler will get raised where you are easier able to manage the action behind.
 
 Below we have 4 options.
@@ -217,13 +256,12 @@ Below we have 4 options.
 ```
 BotBase<Start> bb = new BotBase<Start>("{YOUR API KEY}");
 
-bb.SystemCalls.Add("/start");
+bb.BotCommands.Add(new BotCommand() { Command = "start", Description = "Starts the bot" });
-bb.SystemCalls.Add("/form1");
+bb.BotCommands.Add(new BotCommand() { Command = "form1", Description = "Opens test form 1" });
-bb.SystemCalls.Add("/form2");
+bb.BotCommands.Add(new BotCommand() { Command = "form2", Description = "Opens test form 2" });
+bb.BotCommands.Add(new BotCommand() { Command = "params", Description = "Returns all send parameters as a message." });
 
-bb.SystemCalls.Add("/params");
+bb.BotCommand += async (s, en) =>
-
-bb.SystemCall += async (s, en) =>
 {
 	switch (en.Command)
 	{
@@ -254,6 +292,9 @@ bb.SystemCall += async (s, en) =>
 
 };
 
+//Update Bot commands to botfather
+bb.UploadBotCommands().Wait();
+
 bb.Start();
 
 ```
@@ -268,19 +309,21 @@ On every input the user is sending back to the bot the Action event gets raised.
 ```
 public class SimpleForm : AutoCleanForm
 {
-        public SimpleForm()
+    public SimpleForm()
-        {
+    {
-            this.DeleteSide = eSide.Both;
+        this.DeleteSide = TelegramBotBase.Enums.eDeleteSide.Both;
-            this.DeleteMode = eDeleteMode.OnLeavingForm;
+        this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
-        }
+
+        this.Opened += SimpleForm_Opened;
+    }
 	
-	public override async Task Opened()
+    private async Task SimpleForm_Opened(object sender, EventArgs e)
-	{
+    {
-	    await this.Device.Send("Hello world! (send 'back' to get back to Start)\r\nOr\r\nhi, hello, maybe, bye and ciao");
+        await this.Device.Send("Hello world! (send 'back' to get back to Start)\r\nOr\r\nhi, hello, maybe, bye and ciao");
-	}
+    }
 
 
-	public override async Task Load(MessageResult message)
+    public override async Task Load(MessageResult message)
 	{
 	    //message.MessageText will work also, cause it is a string you could manage a lot different scenerios here
 
@@ -655,7 +698,7 @@ public async override Task Render(MessageResult message)
 ```
 
 There is also a second example, where every of these 3 inputs gets requested by a different formular (class). Just for imagination of the possiblites.
-Cause its to much Text, i didnt have added it here. You will find it under [TelegramBaseTest/Tests/Register/PerStep.cs](TelegramBaseTest/Tests/Register/PerStep.cs)
+Cause its to much Text, i didnt have added it here. You will find it under [TelegramBotBaseTest/Tests/Register/PerStep.cs](TelegramBotBaseTest/Tests/Register/PerStep.cs)
 Beginn there and navigate your way through these Steps in the subfolder.
 
 
@@ -774,6 +817,17 @@ await this.NavigateTo(cd);
 ### Button Grid
 <img src="images/buttongrid.gif?raw=true" />
 
+#### Paging & Searching
+<img src="images/buttongrid_pagingfilter.gif?raw=true" />
+
+### Tagged Button Grid
+<img src="images/taggedbuttongrid.gif?raw=true" />
+
+### Checked Button List
+<img src="images/checkedbuttonlist.gif?raw=true" />
+
+### Multi Toggle Button
+<img src="images/multitogglebutton.gif?raw=true" />
 
 ## Groups
 
@@ -856,6 +910,7 @@ public class GroupForm : FormBase
                 case Telegram.Bot.Types.Enums.MessageType.MessagePinned:
                 case Telegram.Bot.Types.Enums.MessageType.GroupCreated:
                 case Telegram.Bot.Types.Enums.MessageType.SupergroupCreated:
+                case Telegram.Bot.Types.Enums.MessageType.ChannelCreated:
 
                     await OnGroupChanged(new GroupChangedEventArgs(message.MessageType, message));
 
@@ -891,8 +946,234 @@ public class GroupForm : FormBase
 ```
 
 
+## Statemachine and Sessions
+
+Depending on the usecases and the overall structure of a Telegram Bot it is essential to have some kind of session serialization or state machine to keep the user context after restarts of the bot (ie. due to updates) or crashes.
+For this I have created some easy to implement structures which fits into the current environment.
+
+Below you find all possiblities.
+
+### Statemachines
+
+There are actually 3 types of example state machines you could use. A state machine is a kind of serializer which saves the important session data in a reusable structure like JSON or XML.
+
+You could use one of the following state machines:
+
+#### SimpleJSONStateMachine
+Is easy to use and useful for simple structures like basic datatypes. Did not work for complex ones like generics. Use the JSONStateMachine for them.
+In general you didn't need to do more then, to keep the actual form:
+
+```
+//Prepare the System
+BotBase<StartForm> bb = new BotBase<StartForm>("{YOUR API KEY}");
+
+//Add Systemcommands if you like, you could catch them later
+bb.SystemCalls.Add("/start");
+
+//Set the statemachine and enable it
+bb.StateMachine = new TelegramBotBase.States.SimpleJSONStateMachine(AppContext.BaseDirectory + "config\\states.json");
+
+//Start your Bot
+bb.Start();
+
+```
+
+#### JSONStateMachine
+Is easy to use too, but works for complex datatypes cause it saves there namespaces and additional type informations into the JSON file too.
+In general you didn't need to do more then, to keep the actual form:
+
+```
+//Prepare the System
+BotBase<StartForm> bb = new BotBase<StartForm>("{YOUR API KEY}");
+
+//Add Systemcommands if you like, you could catch them later
+bb.SystemCalls.Add("/start");
+
+//Set the statemachine and enable it
+bb.StateMachine = new TelegramBotBase.States.JSONStateMachine(AppContext.BaseDirectory + "config\\states.json");
+
+//Start your Bot
+bb.Start();
+
+```
+
+#### XMLStateMachine
+
+The last one, should work like the others. 
+In general you didn't need to do more then, to keep the actual form:
+
+```
+//Prepare the System
+BotBase<StartForm> bb = new BotBase<StartForm>("{YOUR API KEY}");
+
+//Add Systemcommands if you like, you could catch them later
+bb.SystemCalls.Add("/start");
+
+//Set the statemachine and enable it
+bb.StateMachine = new TelegramBotBase.States.XMLStateMachine(AppContext.BaseDirectory + "config\\states.xml");
+
+//Start your Bot
+bb.Start();
+
+```
+
+### Interfaces
+
+There are two interfaces, one for the StateMachine itself, which is useful to build a custom one for a different datatype and one for implementing into a form which should be invoked with events.
+
+#### IStateMachine
+
+Is the basic StateMachine interface, it has two methods SaveFormStates(SaveStatesEventArgs e) and StateContainer LoadFormStates(), nothing fancy, just simple calls. Implement into both methods your own serialization process.
+
+```
+
+public interface IStateMachine
+{
+    void SaveFormStates(SaveStatesEventArgs e);
+
+    StateContainer LoadFormStates();
+}
+
+```
 
 
+#### IStateForm
+
+When implemented, this will invoke one of these two methods: LoadState(LoadStateEventArgs e) or SaveState(SaveStateEventArgs e).
+They have methods to load or save data from the statemachine of the current form.
+
+```
+
+public interface IStateForm
+{
+    void LoadState(LoadStateEventArgs e);
+
+    void SaveState(SaveStateEventArgs e);
+}
+
+```
+
+### Attributes
+
+If you don't want to implement the IStateForm interface, cause there are maybe "just" one or two properties you want to keep and restore, use the following attribute:
+
+#### SaveState
+
+This will let the engine know, that you want too keep and restore this field automatically. Unlike the IStateForm methods, you have no option to manipulate data.
+
+```
+
+[SaveState]
+public long UserId { get; set; }
+
+
+```
+
+#### IgnoreState
+
+Due to the fact that Attribute implementation and interaction is optional, you want to let the engine maybe know, that you don't want to keep a specific form. So it should get "lost". This attribute will help you here, add it to the form class and it will not get serialized, even if it implements IStateForm or the SaveState attributes.
+
+```
+
+[IgnoreState]
+public class Registration : STForm
+{
+
+}
+
+```
+
+## Navigation and NavigationController
+
+### As of now
+
+As from earlier topics on this readme you already know the default way for (cross) navigation between Forms.
+It will look something like this:
+
+```
+
+var f = new FormBase();
+await this.NavigateTo(f);
+
+```
+
+Depending on the model and structure of your bot it can make sense, to have more linear navigation instead of "cross" navigation.
+
+In example you have a bot which shows a list of football teams. And when clicking on it you want to open the team details and latest matches.
+
+After the matches you want to maybe switch to a different teams and take a look at their statistics and matches.
+
+At some point, you "just" want to get back to the first team so like on Android your clicking the "back" button multiple times.
+
+This can become really complicated, when not having some controller below which handle these "Push/Pop" calls.
+
+Thats why I introduced a NavigationController class which manages these situations and the stack.
+
+
+### How to use ?
+
+First you need to create a NavigationController instance at the same position in code, where you want to start the navigation.
+
+You will use the current FormBase instance as a root class within the constructor. So you can later come back to this one.
+
+**Tip**: *You can add also a completely new instance of i.e. a main menu form here to get back to it then. So you are free to choose.*
+
+We are using the same FormBase instance as above.
+
+
+```
+
+var nc = new NavigationController(this);
+
+var f = new FormBase();
+
+//Replace the current form in the context with the controller.
+await this.NavigateTo(nc);
+
+//Push the new from onto the stack to render it
+nc.PushAsync(f);
+
+```
+
+
+Later to open a new form use PushAsync again:
+
+```
+
+await this.NavigationController.PushAsync(newForm);
+
+```
+
+When you want to go back one Form on the stack use PopAsync:
+
+
+```
+
+await this.NavigationController.PopAsync();
+
+```
+
+**Notice**: *By default the NavigationController has ForceCleanupOnLastPop enabled, which means that when the stack is again at 1 (due to PopAsync or PopToRootAsync calls) it will replace the controller automatically with the root form you have given to the constructor at the beginning.*
+
+
+
+
+
+## Examples
+
+You find all example projects in the "Examples" subfolder.
+
+- [Examples/SystemCommandsBot/](Examples/SystemCommandsBot/) 
+
+Will allow you to run specific system commands or run/kill processes via Bot. Has also a simple authentication mechanism with one password.
+
+- [Examples/JoinHiderBot/](Examples/JoinHiderBot/) 
+
+Will delete Join and Leave messages automatically in groups.
+
+- [Examples/AsyncFormUpdates/](Examples/AsyncFormUpdates/) 
+
+When you want to update forms async without any user interaction (message/action) before. Use the new InvokeMessageLoop method of BotBase.
 
 ---
 

TelegramBotBase/Args/BotCommandEventArgs.cs

@@ -9,9 +9,9 @@ using TelegramBotBase.Sessions;
 namespace TelegramBotBase.Args
 {
     /// <summary>
-    /// Base class for given system call results
+    /// Base class for given bot command results
     /// </summary>
-    public class SystemCallEventArgs : EventArgs
+    public class BotCommandEventArgs : EventArgs
     {
         public String Command { get; set; }
 
@@ -26,13 +26,13 @@ namespace TelegramBotBase.Args
         public Message OriginalMessage { get; set; }
 
 
-        public SystemCallEventArgs()
+        public BotCommandEventArgs()
         {
 
 
         }
 
-        public SystemCallEventArgs(String Command, List<String> Parameters, Message Message, long DeviceId, DeviceSession Device)
+        public BotCommandEventArgs(String Command, List<String> Parameters, Message Message, long DeviceId, DeviceSession Device)
         {
             this.Command = Command;
             this.Parameters = Parameters;

TelegramBotBase/Args/ButtonClickedEventArgs.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using TelegramBotBase.Controls.Hybrid;
 using TelegramBotBase.Form;
 
 namespace TelegramBotBase.Args
@@ -14,6 +15,12 @@ namespace TelegramBotBase.Args
     {
         public ButtonBase Button { get; set; }
 
+        public int Index { get; set; }
+
+        public object Tag { get; set; }
+
+        public ButtonRow Row { get; set; }
+
 
         public ButtonClickedEventArgs()
         {
@@ -23,7 +30,20 @@ namespace TelegramBotBase.Args
         public ButtonClickedEventArgs(ButtonBase button)
         {
             this.Button = button;
+            this.Index = -1;
         }
 
+        public ButtonClickedEventArgs(ButtonBase button, int Index)
+        {
+            this.Button = button;
+            this.Index = Index;
+        }
+
+        public ButtonClickedEventArgs(ButtonBase button, int Index, ButtonRow row)
+        {
+            this.Button = button;
+            this.Index = Index;
+            this.Row = row;
+        }
     }
 }

TelegramBotBase/Args/CheckedChangedEventArgs.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Args
+{
+    public class CheckedChangedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Contains the index of the row where the button is inside. 
+        /// Contains -1 when it is a layout button or not found.
+        /// </summary>
+        public int Index { get; set; }
+
+
+        /// <summary>
+        /// Contains all buttons within this row, excluding the checkbox.
+        /// </summary>
+        public ButtonRow Row { get; set; }
+
+
+        /// <summary>
+        /// Contains the new checked status of the row.
+        /// </summary>
+        public bool Checked { get; set; }
+
+
+        public CheckedChangedEventArgs()
+        {
+
+        }
+
+        public CheckedChangedEventArgs(ButtonRow row, int Index, bool Checked)
+        {
+            this.Row = row;
+            this.Index = Index;
+            this.Checked = Checked;
+        }
+
+
+    }
+}

TelegramBotBase/Args/LoadStateEventArgs.cs

@@ -54,5 +54,10 @@ namespace TelegramBotBase.Args
             return false;
         }
 
+        public object GetObject(String key)
+        {
+            return Values[key];
+        }
+
     }
 }

TelegramBotBase/Args/MessageDeletedEventArgs.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Telegram.Bot.Types;
+
+namespace TelegramBotBase.Args
+{
+    public class MessageDeletedEventArgs
+    {
+        public int MessageId
+        {
+            get;set;
+        }
+
+        public MessageDeletedEventArgs(int messageId)
+        {
+            this.MessageId = messageId;
+        }
+
+    }
+}

TelegramBotBase/Args/MessageSentEventArgs.cs

@@ -19,9 +19,16 @@ namespace TelegramBotBase.Args
 
         public Message Message { get; set; }
 
-        public MessageSentEventArgs(Message message)
+        /// <summary>
+        /// Contains the element, which has called the method.
+        /// </summary>
+        public Type Origin { get; set; }
+
+
+        public MessageSentEventArgs(Message message, Type Origin)
         {
             this.Message = message;
+            this.Origin = Origin;
         }
 
 

TelegramBotBase/Args/PromptDialogCompletedEventArgs.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Args
+{
+    public class PromptDialogCompletedEventArgs
+    {
+        public object Tag { get; set; }
+
+        public String Value { get; set; }
+
+    }
+}

TelegramBotBase/Args/RenderViewEventArgs.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Args
+{
+    public class RenderViewEventArgs : EventArgs
+    {
+        public int CurrentView { get; set; }
+
+
+        public RenderViewEventArgs(int ViewIndex)
+        {
+
+            CurrentView = ViewIndex;
+        }
+
+
+    }
+}

TelegramBotBase/Args/SaveStateEventArgs.cs

@@ -32,6 +32,10 @@ namespace TelegramBotBase.Args
         {
             Values[key] = value;
         }
+        public void SetObject(String key, object value)
+        {
+            Values[key] = value;
+        }
 
     }
 }

TelegramBotBase/Base/ControlBase.cs

@@ -28,19 +28,27 @@ namespace TelegramBotBase.Base
         /// </summary>
         public bool Enabled { get; set; } = true;
 
+        /// <summary>
+        /// Get invoked when control will be added to a form and invoked.
+        /// </summary>
+        /// <returns></returns>
+        public virtual void Init()
+        {
+
+        }
 
         public virtual async Task Load(MessageResult result)
         {
 
 
-
+            
         }
 
         public virtual async Task Action(MessageResult result, String value = null)
         {
 
 
-
+            
         }
 
 
@@ -50,18 +58,22 @@ namespace TelegramBotBase.Base
 
 
 
-
+            
         }
 
         public virtual async Task Hidden(bool FormClose)
         {
 
-
+            
         }
 
+        /// <summary>
+        /// Will be called on a cleanup.
+        /// </summary>
+        /// <returns></returns>
         public virtual async Task Cleanup()
         {
-
+            
         }
 
     }

TelegramBotBase/Base/DataResult.cs

@@ -105,10 +105,16 @@ namespace TelegramBotBase.Base
         {
             var encryptedContent = new System.IO.MemoryStream(this.Document.FileSize);
             var file = await this.Client.TelegramClient.GetInfoAndDownloadFileAsync(this.Document.FileId, encryptedContent);
-            
+
             return new InputOnlineFile(encryptedContent, this.Document.FileName);
         }
 
+
+        /// <summary>
+        /// Downloads a file and saves it to the given path.
+        /// </summary>
+        /// <param name="path"></param>
+        /// <returns></returns>
         public async Task DownloadDocument(String path)
         {
             var file = await this.Client.TelegramClient.GetFileAsync(this.Document.FileId);
@@ -118,11 +124,47 @@ namespace TelegramBotBase.Base
             fs.Dispose();
         }
 
+        /// <summary>
+        /// Downloads the document and returns an byte array.
+        /// </summary>
+        /// <returns></returns>
+        public async Task<byte[]> DownloadRawDocument()
+        {
+            MemoryStream ms = new MemoryStream();
+            await this.Client.TelegramClient.GetInfoAndDownloadFileAsync(this.Document.FileId, ms);
+            return ms.ToArray();
+        }
+
+        /// <summary>
+        /// Downloads  a document and returns it as string. (txt,csv,etc) Default encoding ist UTF8.
+        /// </summary>
+        /// <returns></returns>
+        public async Task<String> DownloadRawTextDocument()
+        {
+            return await DownloadRawTextDocument(Encoding.UTF8);
+        }
+
+        /// <summary>
+        /// Downloads  a document and returns it as string. (txt,csv,etc)
+        /// </summary>
+        /// <returns></returns>
+        public async Task<String> DownloadRawTextDocument(Encoding encoding)
+        {
+            MemoryStream ms = new MemoryStream();
+            await this.Client.TelegramClient.GetInfoAndDownloadFileAsync(this.Document.FileId, ms);
+
+            ms.Position = 0;
+
+            var sr = new StreamReader(ms, encoding);
+            
+            return sr.ReadToEnd();
+        }
+
         public async Task<InputOnlineFile> DownloadVideo()
         {
             var encryptedContent = new System.IO.MemoryStream(this.Video.FileSize);
             var file = await this.Client.TelegramClient.GetInfoAndDownloadFileAsync(this.Video.FileId, encryptedContent);
-            
+
             return new InputOnlineFile(encryptedContent, "");
         }
 
@@ -157,7 +199,7 @@ namespace TelegramBotBase.Base
             var photo = this.Photos[index];
             var encryptedContent = new System.IO.MemoryStream(photo.FileSize);
             var file = await this.Client.TelegramClient.GetInfoAndDownloadFileAsync(photo.FileId, encryptedContent);
-            
+
             return new InputOnlineFile(encryptedContent, "");
         }
 

TelegramBotBase/Base/FormBase.cs

@@ -6,6 +6,7 @@ using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Args;
 using TelegramBotBase.Base;
+using TelegramBotBase.Form.Navigation;
 using TelegramBotBase.Sessions;
 using static TelegramBotBase.Base.Async;
 
@@ -17,6 +18,8 @@ namespace TelegramBotBase.Form
     public class FormBase : IDisposable
     {
 
+        public NavigationController NavigationController { get; set; }
+
         public DeviceSession Device { get; set; }
 
         public MessageClient Client { get; set; }
@@ -55,7 +58,10 @@ namespace TelegramBotBase.Form
             if (this.Events[__evInit] == null)
                 return;
 
-            var handler = this.Events[__evInit].GetInvocationList().Cast<AsyncEventHandler<InitEventArgs>>();
+            var handler = this.Events[__evInit]?.GetInvocationList().Cast<AsyncEventHandler<InitEventArgs>>();
+            if (handler == null)
+                return;
+
             foreach (var h in handler)
             {
                 await Async.InvokeAllAsync<InitEventArgs>(h, this, e);
@@ -84,7 +90,10 @@ namespace TelegramBotBase.Form
             if (this.Events[__evOpened] == null)
                 return;
 
-            var handler = this.Events[__evOpened].GetInvocationList().Cast<AsyncEventHandler<EventArgs>>();
+            var handler = this.Events[__evOpened]?.GetInvocationList().Cast<AsyncEventHandler<EventArgs>>();
+            if (handler == null)
+                return;
+
             foreach (var h in handler)
             {
                 await Async.InvokeAllAsync<EventArgs>(h, this, e);
@@ -114,7 +123,10 @@ namespace TelegramBotBase.Form
             if (this.Events[__evClosed] == null)
                 return;
 
-            var handler = this.Events[__evClosed].GetInvocationList().Cast<AsyncEventHandler<EventArgs>>();
+            var handler = this.Events[__evClosed]?.GetInvocationList().Cast<AsyncEventHandler<EventArgs>>();
+            if (handler == null)
+                return;
+
             foreach (var h in handler)
             {
                 await Async.InvokeAllAsync<EventArgs>(h, this, e);
@@ -171,7 +183,7 @@ namespace TelegramBotBase.Form
         /// </summary>
         /// <param name="message"></param>
         /// <returns></returns>
-        public async Task LoadControls(MessageResult message)
+        public virtual async Task LoadControls(MessageResult message)
         {
             //Looking for the control by id, if not listened, raise event for all
             if (message.RawData?.StartsWith("#c") ?? false)
@@ -219,7 +231,7 @@ namespace TelegramBotBase.Form
         /// </summary>
         /// <param name="message"></param>
         /// <returns></returns>
-        public async Task ActionControls(MessageResult message)
+        public virtual async Task ActionControls(MessageResult message)
         {
             //Looking for the control by id, if not listened, raise event for all
             if (message.RawData.StartsWith("#c"))
@@ -269,7 +281,7 @@ namespace TelegramBotBase.Form
         /// </summary>
         /// <param name="message"></param>
         /// <returns></returns>
-        public async Task RenderControls(MessageResult message)
+        public virtual async Task RenderControls(MessageResult message)
         {
             foreach (var b in this.Controls)
             {
@@ -391,9 +403,15 @@ namespace TelegramBotBase.Form
         /// <param name="control"></param>
         public void AddControl(ControlBase control)
         {
+            //Duplicate check
+            if (this.Controls.Contains(control))
+                throw new ArgumentException("Control has been already added.");
+
             control.ID = this.Controls.Count + 1;
             control.Device = this.Device;
             this.Controls.Add(control);
+
+            control.Init();
         }
 
         /// <summary>
@@ -410,6 +428,19 @@ namespace TelegramBotBase.Form
             this.Controls.Remove(control);
         }
 
+        /// <summary>
+        /// Removes all controls.
+        /// </summary>
+        public void RemoveAllControls()
+        {
+            foreach(var c in this.Controls)
+            {
+                c.Cleanup().Wait();
+
+                this.Controls.Remove(c);
+            }
+        }
+
         /// <summary>
         /// Cleanup
         /// </summary>

TelegramBotBase/Base/MessageClient.cs

@@ -6,6 +6,7 @@ using System.Net;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
+using Telegram.Bot.Types;
 
 namespace TelegramBotBase.Base
 {
@@ -15,6 +16,7 @@ namespace TelegramBotBase.Base
     public class MessageClient
     {
 
+
         public String APIKey { get; set; }
 
         public Telegram.Bot.TelegramBotClient TelegramClient { get; set; }
@@ -40,7 +42,7 @@ namespace TelegramBotBase.Base
         {
             this.APIKey = APIKey;
             this.TelegramClient = new Telegram.Bot.TelegramBotClient(APIKey, proxy);
-           
+
 
             Prepare();
         }
@@ -142,6 +144,27 @@ namespace TelegramBotBase.Base
             }
         }
 
+        /// <summary>
+        /// This will return the current list of bot commands.
+        /// </summary>
+        /// <returns></returns>
+        public async Task<BotCommand[]> GetBotCommands()
+        {
+            return await this.TelegramClient.GetMyCommandsAsync();
+        }
+
+        /// <summary>
+        /// This will set your bot commands to the given list.
+        /// </summary>
+        /// <param name="botcommands"></param>
+        /// <returns></returns>
+        public async Task SetBotCommands(List<BotCommand> botcommands)
+        {
+            await this.TelegramClient.SetMyCommandsAsync(botcommands);
+        }
+
+
+
 
         #region "Events"
 

TelegramBotBase/Base/MessageResult.cs

@@ -20,12 +20,18 @@ namespace TelegramBotBase.Base
         {
             get
             {
-                return this.RawMessageData?.Message?.Chat.Id ?? this.RawCallbackData?.CallbackQuery.Message?.Chat.Id ?? 0;
+                return this.RawMessageData?.Message?.Chat.Id
+                    ?? this.RawCallbackData?.CallbackQuery.Message?.Chat.Id
+                    ?? Device?.DeviceId
+                    ?? 0;
             }
         }
 
         public DeviceSession Device
-        { get; set; }
+        {
+            get;
+            set;
+        }
 
         /// <summary>
         /// The message id
@@ -34,7 +40,9 @@ namespace TelegramBotBase.Base
         {
             get
             {
-                return this.Message?.MessageId ?? this.RawCallbackData?.CallbackQuery?.Message?.MessageId ?? 0;
+                return this.Message?.MessageId 
+                    ?? this.RawCallbackData?.CallbackQuery?.Message?.MessageId 
+                    ?? 0;
             }
         }
 
@@ -58,7 +66,8 @@ namespace TelegramBotBase.Base
         {
             get
             {
-                return this.RawMessageData?.Message?.Type ?? Telegram.Bot.Types.Enums.MessageType.Unknown;
+                return this.RawMessageData?.Message?.Type 
+                    ?? Telegram.Bot.Types.Enums.MessageType.Unknown;
             }
         }
 
@@ -74,9 +83,9 @@ namespace TelegramBotBase.Base
         }
 
         /// <summary>
-        /// Is this a system call ? Starts with a slash '/' and a command
+        /// Is this a command ? Starts with a slash '/' and a command
         /// </summary>
-        public bool IsSystemCall
+        public bool IsBotCommand
         {
             get
             {
@@ -87,11 +96,11 @@ namespace TelegramBotBase.Base
         /// <summary>
         /// Returns a List of all parameters which has been sent with the command itself (i.e. /start 123 456 789 => 123,456,789)
         /// </summary>
-        public List<String> SystemCallParameters
+        public List<String> BotCommandParameters
         {
             get
             {
-                if (!IsSystemCall)
+                if (!IsBotCommand)
                     return new List<string>();
 
                 //Split by empty space and skip first entry (command itself), return as list
@@ -100,13 +109,13 @@ namespace TelegramBotBase.Base
         }
 
         /// <summary>
-        /// Returns just the System call command (i.e. /start 1 2 3 => /start)
+        /// Returns just the command (i.e. /start 1 2 3 => /start)
         /// </summary>
-        public String SystemCommand
+        public String BotCommand
         {
             get
             {
-                if (!IsSystemCall)
+                if (!IsBotCommand)
                     return null;
 
                 return this.MessageText.Split(' ')[0];
@@ -151,11 +160,11 @@ namespace TelegramBotBase.Base
         /// </summary>
         /// <param name="message"></param>
         /// <returns></returns>
-        public async Task ConfirmAction(String message = "")
+        public async Task ConfirmAction(String message = "", bool showAlert = false, String urlToOpen = null)
         {
             try
             {
-                await this.Client.TelegramClient.AnswerCallbackQueryAsync(this.RawCallbackData.CallbackQuery.Id, message);
+                await this.Client.TelegramClient.AnswerCallbackQueryAsync(this.RawCallbackData.CallbackQuery.Id, message, showAlert, urlToOpen);
             }
             catch
             {
@@ -175,6 +184,10 @@ namespace TelegramBotBase.Base
             }
         }
 
+        internal MessageResult()
+        {
+
+        }
 
         public MessageResult(Telegram.Bot.Args.MessageEventArgs rawdata)
         {

TelegramBotBase/BotBase.cs

@@ -5,9 +5,11 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Telegram.Bot;
+using Telegram.Bot.Types;
 using TelegramBotBase.Args;
 using TelegramBotBase.Attributes;
 using TelegramBotBase.Base;
+using TelegramBotBase.Enums;
 using TelegramBotBase.Form;
 using TelegramBotBase.Interfaces;
 using TelegramBotBase.Sessions;
@@ -31,12 +33,15 @@ namespace TelegramBotBase
         /// <summary>
         /// List of all running/active sessions
         /// </summary>
-        public SessionBase Sessions { get; set; }
+        public SessionBase<T> Sessions { get; set; }
 
         /// <summary>
         /// Contains System commands which will be available at everytime and didnt get passed to forms, i.e. /start
         /// </summary>
-        public List<String> SystemCalls { get; set; }
+        public List<BotCommand> BotCommands { get; set; }
+
+
+        #region "Events"
 
         private EventHandlerList __Events = new EventHandlerList();
 
@@ -46,47 +51,53 @@ namespace TelegramBotBase
 
         private static object __evSystemCall = new object();
 
-        public delegate Task SystemCallEventHandler(object sender, SystemCallEventArgs e);
+        public delegate Task BotCommandEventHandler(object sender, BotCommandEventArgs e);
 
         private static object __evException = new object();
 
         private static object __evUnhandledCall = new object();
 
+        #endregion
 
-        /// <summary>
-        /// Skips all messages during running (good for big delay updates)
-        /// </summary>
-        public bool SkipAllMessages { get; set; } = false;
-
-        /// <summary>
-        /// Loggs all messages and sent them to the event handler
-        /// </summary>
-        public bool LogAllMessages { get; set; } = false;
 
         /// <summary>
         /// Enable the SessionState (you need to implement on call forms the IStateForm interface)
         /// </summary>
         public IStateMachine StateMachine { get; set; }
 
-        /// <summary>
+
-        /// How often could a form navigate to another (within one user action/call/message)
+        public Dictionary<eSettings, uint> SystemSettings { get; private set; }
-        /// </summary>
+
-        private const int NavigationMaximum = 10;
+        private BotBase()
+        {
+            this.SystemSettings = new Dictionary<eSettings, uint>();
+
+            SetSetting(eSettings.MaxNumberOfRetries, 5);
+            SetSetting(eSettings.NavigationMaximum, 10);
+            SetSetting(eSettings.LogAllMessages, false);
+            SetSetting(eSettings.SkipAllMessages, false);
+            SetSetting(eSettings.SaveSessionsOnConsoleExit, false);
+
+            this.BotCommands = new List<BotCommand>();
+
+            this.Sessions = new SessionBase<T>();
+            this.Sessions.BotBase = this;
+        }
 
         /// <summary>
         /// Simple start of your Bot with the APIKey
         /// </summary>
         /// <param name="apiKey"></param>
-        public BotBase(String apiKey)
+        public BotBase(String apiKey, bool initClient = true) : this()
         {
             this.APIKey = apiKey;
 
+            if (!initClient)
+                return;
+
             this.Client = new Base.MessageClient(this.APIKey);
             this.Client.TelegramClient.Timeout = new TimeSpan(0, 1, 0);
 
-            this.SystemCalls = new List<string>();
-
-            this.Sessions = new SessionBase();
             this.Sessions.Client = this.Client;
         }
 
@@ -95,15 +106,10 @@ namespace TelegramBotBase
         /// </summary>
         /// <param name="apiKey"></param>
         /// <param name="proxyBaseAddress">i.e. https://127.0.0.1:10000</param>
-        public BotBase(String apiKey, System.Net.Http.HttpClient proxy)
+        public BotBase(String apiKey, System.Net.Http.HttpClient proxy) : this(apiKey, false)
         {
-            this.APIKey = apiKey;
-
             this.Client = new Base.MessageClient(this.APIKey, proxy);
 
-            this.SystemCalls = new List<string>();
-
-            this.Sessions = new SessionBase();
             this.Sessions.Client = this.Client;
         }
 
@@ -112,15 +118,10 @@ namespace TelegramBotBase
         /// </summary>
         /// <param name="apiKey"></param>
         /// <param name="client"></param>
-        public BotBase(String apiKey, TelegramBotClient client)
+        public BotBase(String apiKey, TelegramBotClient client) : this(apiKey, false)
         {
-            this.APIKey = apiKey;
-
             this.Client = new Base.MessageClient(this.APIKey, client);
 
-            this.SystemCalls = new List<string>();
-
-            this.Sessions = new SessionBase();
             this.Sessions.Client = this.Client;
         }
 
@@ -129,17 +130,12 @@ namespace TelegramBotBase
         /// </summary>
         /// <param name="apiKey"></param>
         /// <param name="proxyBaseAddress">i.e. https://127.0.0.1:10000</param>
-        public BotBase(String apiKey, String proxyBaseAddress)
+        public BotBase(String apiKey, String proxyBaseAddress) : this(apiKey, false)
         {
-            this.APIKey = apiKey;
-
             var url = new Uri(proxyBaseAddress);
 
             this.Client = new Base.MessageClient(this.APIKey, url);
 
-            this.SystemCalls = new List<string>();
-
-            this.Sessions = new SessionBase();
             this.Sessions.Client = this.Client;
         }
 
@@ -149,15 +145,10 @@ namespace TelegramBotBase
         /// <param name="apiKey"></param>
         /// <param name="proxyHost">i.e. 127.0.0.1</param>
         /// <param name="proxyPort">i.e. 10000</param>
-        public BotBase(String apiKey, String proxyHost, int proxyPort)
+        public BotBase(String apiKey, String proxyHost, int proxyPort) : this(apiKey, false)
         {
-            this.APIKey = apiKey;
-
             this.Client = new Base.MessageClient(this.APIKey, proxyHost, proxyPort);
 
-            this.SystemCalls = new List<string>();
-
-            this.Sessions = new SessionBase();
             this.Sessions.Client = this.Client;
         }
 
@@ -178,6 +169,17 @@ namespace TelegramBotBase
                 this.Sessions.LoadSessionStates(this.StateMachine);
             }
 
+            //Enable auto session saving
+            if (this.GetSetting(eSettings.SaveSessionsOnConsoleExit, false))
+            {
+                TelegramBotBase.Tools.Console.SetHandler(() =>
+                {
+                    this.Sessions.SaveSessionStates();
+                });
+            }
+
+            DeviceSession.MaxNumberOfRetries = this.GetSetting(eSettings.MaxNumberOfRetries, 5);
+
             this.Client.TelegramClient.StartReceiving();
         }
 
@@ -195,10 +197,7 @@ namespace TelegramBotBase
 
             this.Client.TelegramClient.StopReceiving();
 
-            if (this.StateMachine != null)
+            this.Sessions.SaveSessionStates();
-            {
-                this.Sessions.SaveSessionStates(this.StateMachine);
-            }
         }
 
         /// <summary>
@@ -219,7 +218,7 @@ namespace TelegramBotBase
 
         private async void Client_Message(object sender, MessageResult e)
         {
-            if (this.SkipAllMessages)
+            if (this.GetSetting(eSettings.SkipAllMessages, false))
                 return;
 
             try
@@ -227,14 +226,14 @@ namespace TelegramBotBase
                 DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
                 e.Device = ds;
 
-                if (LogAllMessages)
+                if (this.GetSetting(eSettings.LogAllMessages, false))
                 {
                     OnMessage(new MessageIncomeEventArgs(e.DeviceId, ds, e));
                 }
 
                 ds?.OnMessageReceived(new MessageReceivedEventArgs(e.Message));
 
-                await Client_TryMessage(sender, e);
+                await Client_Loop(sender, e);
             }
             catch (Telegram.Bot.Exceptions.ApiRequestException ex)
             {
@@ -247,28 +246,99 @@ namespace TelegramBotBase
             }
         }
 
-        private async Task Client_TryMessage(object sender, MessageResult e)
+
+
+        //private async Task Client_TryMessage(object sender, MessageResult e)
+        //{
+        //    DeviceSession ds = e.Device;
+        //    if (ds == null)
+        //    {
+        //        ds = await this.Sessions.StartSession<T>(e.DeviceId);
+        //        e.Device = ds;
+
+        //        ds.LastMessage = e.Message;
+
+        //        OnSessionBegins(new SessionBeginEventArgs(e.DeviceId, ds));
+        //    }
+
+        //    ds.LastAction = DateTime.Now;
+        //    ds.LastMessage = e.Message;
+
+        //    //Is this a bot command ?
+        //    if (e.IsBotCommand && this.BotCommands.Count(a => "/" + a.Command == e.BotCommand) > 0)
+        //    {
+        //        var sce = new BotCommandEventArgs(e.BotCommand, e.BotCommandParameters, e.Message, ds.DeviceId, ds);
+        //        await OnBotCommand(sce);
+
+        //        if (sce.Handled)
+        //            return;
+        //    }
+
+        //    FormBase activeForm = null;
+
+        //    int i = 0;
+
+        //    //Should formulars get navigated (allow maximum of 10, to dont get loops)
+        //    do
+        //    {
+        //        i++;
+
+        //        //Reset navigation
+        //        ds.FormSwitched = false;
+
+        //        activeForm = ds.ActiveForm;
+
+        //        //Pre Loading Event
+        //        await activeForm.PreLoad(e);
+
+        //        //Send Load event to controls
+        //        await activeForm.LoadControls(e);
+
+        //        //Loading Event
+        //        await activeForm.Load(e);
+
+        //        //Is Attachment ? (Photo, Audio, Video, Contact, Location, Document)
+        //        if (e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Contact | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Document | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Location |
+        //            e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Photo | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Video | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Audio)
+        //        {
+        //            await activeForm.SentData(new DataResult(e));
+        //        }
+
+        //        //Render Event
+        //        if (!ds.FormSwitched)
+        //        {
+        //            await activeForm.RenderControls(e);
+
+        //            await activeForm.Render(e);
+        //        }
+
+        //        e.IsFirstHandler = false;
+
+        //    } while (ds.FormSwitched && i < this.GetSetting(eSettings.NavigationMaximum, 10));
+
+
+        //}
+
+        private async Task Client_Loop(object sender, MessageResult e)
         {
             DeviceSession ds = e.Device;
             if (ds == null)
             {
                 ds = await this.Sessions.StartSession<T>(e.DeviceId);
                 e.Device = ds;
-
                 ds.LastMessage = e.Message;
 
                 OnSessionBegins(new SessionBeginEventArgs(e.DeviceId, ds));
             }
 
-            ds.ChatTitle = e.Message.Chat.Username ?? e.Message.Chat.Title;
             ds.LastAction = DateTime.Now;
             ds.LastMessage = e.Message;
 
-            //Is this a systemcall ?
+            //Is this a bot command ?
-            if (e.IsSystemCall && this.SystemCalls.Contains(e.SystemCommand))
+            if (e.IsBotCommand && this.BotCommands.Count(a => "/" + a.Command == e.BotCommand) > 0)
             {
-                var sce = new SystemCallEventArgs(e.SystemCommand, e.SystemCallParameters, e.Message, ds.DeviceId, ds);
+                var sce = new BotCommandEventArgs(e.BotCommand, e.BotCommandParameters, e.Message, ds.DeviceId, ds);
-                await OnSystemCall(sce);
+                await OnBotCommand(sce);
 
                 if (sce.Handled)
                     return;
@@ -298,15 +368,41 @@ namespace TelegramBotBase
                 await activeForm.Load(e);
 
                 //Is Attachment ? (Photo, Audio, Video, Contact, Location, Document)
-                if (e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Contact | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Document | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Location |
+                if (e.MessageType == Telegram.Bot.Types.Enums.MessageType.Contact | e.MessageType == Telegram.Bot.Types.Enums.MessageType.Document | e.MessageType == Telegram.Bot.Types.Enums.MessageType.Location |
-                    e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Photo | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Video | e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Audio)
+                    e.MessageType == Telegram.Bot.Types.Enums.MessageType.Photo | e.MessageType == Telegram.Bot.Types.Enums.MessageType.Video | e.MessageType == Telegram.Bot.Types.Enums.MessageType.Audio)
                 {
                     await activeForm.SentData(new DataResult(e));
                 }
 
-                //Render Event
+                //Action Event
+                if (!ds.FormSwitched && e.IsAction)
+                {
+                    //Send Action event to controls
+                    await activeForm.ActionControls(e);
+
+                    //Send Action event to form itself
+                    await activeForm.Action(e);
+
+                    if (!e.Handled)
+                    {
+                        var uhc = new UnhandledCallEventArgs(e.Message.Text, e.RawData, ds.DeviceId, e.MessageId, e.Message, ds);
+                        OnUnhandledCall(uhc);
+
+                        if (uhc.Handled)
+                        {
+                            e.Handled = true;
+                            if (!ds.FormSwitched)
+                            {
+                                break;
+                            }
+                        }
+                    }
+
+                }
+
                 if (!ds.FormSwitched)
                 {
+                    //Render Event
                     await activeForm.RenderControls(e);
 
                     await activeForm.Render(e);
@@ -314,14 +410,46 @@ namespace TelegramBotBase
 
                 e.IsFirstHandler = false;
 
-            } while (ds.FormSwitched && i < NavigationMaximum);
+            } while (ds.FormSwitched && i < this.GetSetting(eSettings.NavigationMaximum, 10));
 
 
         }
 
+        /// <summary>
+        /// This will invoke the full message loop for the device even when no "userevent" like message or action has been raised.
+        /// </summary>
+        /// <param name="DeviceId">Contains the device/chat id of the device to update.</param>
+        public async Task InvokeMessageLoop(long DeviceId)
+        {
+            var mr = new MessageResult();
+
+            await InvokeMessageLoop(DeviceId, mr);
+        }
+
+        /// <summary>
+        /// This will invoke the full message loop for the device even when no "userevent" like message or action has been raised.
+        /// </summary>
+        /// <param name="DeviceId">Contains the device/chat id of the device to update.</param>
+        /// <param name="e"></param>
+        public async Task InvokeMessageLoop(long DeviceId, MessageResult e)
+        {
+            try
+            {
+                DeviceSession ds = this.Sessions.GetSession(DeviceId);
+                e.Device = ds;
+
+                await Client_Loop(this, e);
+            }
+            catch (Exception ex)
+            {
+                DeviceSession ds = this.Sessions.GetSession(DeviceId);
+                OnException(new SystemExceptionEventArgs(e.Message.Text, DeviceId, ds, ex));
+            }
+        }
+
         private async void Client_MessageEdit(object sender, MessageResult e)
         {
-            if (this.SkipAllMessages)
+            if (this.GetSetting(eSettings.SkipAllMessages, false))
                 return;
 
             try
@@ -329,7 +457,7 @@ namespace TelegramBotBase
                 DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
                 e.Device = ds;
 
-                if (LogAllMessages)
+                if (this.GetSetting(eSettings.LogAllMessages, false))
                 {
                     OnMessage(new MessageIncomeEventArgs(e.DeviceId, ds, e));
                 }
@@ -359,7 +487,6 @@ namespace TelegramBotBase
                 e.Device = ds;
             }
 
-            ds.ChatTitle = e.Message.Chat.Username ?? e.Message.Chat.Title;
             ds.LastAction = DateTime.Now;
             ds.LastMessage = e.Message;
 
@@ -369,24 +496,24 @@ namespace TelegramBotBase
             //When form has been switched due navigation within the edit method, reopen Client_Message
             if (ds.FormSwitched)
             {
-                await Client_TryMessage(sender, e);
+                await Client_Loop(sender, e);
             }
 
         }
 
-        private void Client_Action(object sender, MessageResult e)
+        private async void Client_Action(object sender, MessageResult e)
         {
             try
             {
                 DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
                 e.Device = ds;
 
-                if (LogAllMessages)
+                if (this.GetSetting(eSettings.LogAllMessages, false))
                 {
                     OnMessage(new MessageIncomeEventArgs(e.DeviceId, ds, e));
                 }
 
-                Client_TryAction(sender, e);
+                await Client_Loop(sender, e);
             }
             catch (Exception ex)
             {
@@ -395,85 +522,139 @@ namespace TelegramBotBase
             }
         }
 
-        private async void Client_TryAction(object sender, MessageResult e)
+        //private async void Client_TryAction(object sender, MessageResult e)
+        //{
+        //    DeviceSession ds = e.Device;
+        //    if (ds == null)
+        //    {
+        //        ds = await this.Sessions.StartSession<T>(e.DeviceId);
+        //        e.Device = ds;
+        //    }
+
+        //    ds.LastAction = DateTime.Now;
+        //    ds.LastMessage = e.Message;
+
+        //    FormBase activeForm = null;
+
+        //    int i = 0;
+
+        //    //Should formulars get navigated (allow maximum of 10, to dont get loops)
+        //    do
+        //    {
+        //        i++;
+
+        //        //Reset navigation
+        //        ds.FormSwitched = false;
+
+        //        activeForm = ds.ActiveForm;
+
+        //        //Pre Loading Event
+        //        await activeForm.PreLoad(e);
+
+        //        //Send Load event to controls
+        //        await activeForm.LoadControls(e);
+
+        //        //Loading Event
+        //        await activeForm.Load(e);
+
+        //        //Action Event
+        //        if (!ds.FormSwitched)
+        //        {
+        //            //Send Action event to controls
+        //            await activeForm.ActionControls(e);
+
+        //            //Send Action event to form itself
+        //            await activeForm.Action(e);
+
+        //            if (!e.Handled)
+        //            {
+        //                var uhc = new UnhandledCallEventArgs(e.Message.Text, e.RawData, ds.DeviceId, e.MessageId, e.Message, ds);
+        //                OnUnhandledCall(uhc);
+
+        //                if (uhc.Handled)
+        //                {
+        //                    e.Handled = true;
+        //                    if (!ds.FormSwitched)
+        //                    {
+        //                        break;
+        //                    }
+        //                }
+        //            }
+
+        //        }
+
+        //        //Render Event
+        //        if (!ds.FormSwitched)
+        //        {
+        //            await activeForm.RenderControls(e);
+
+        //            await activeForm.Render(e);
+        //        }
+
+        //        e.IsFirstHandler = false;
+
+        //    } while (ds.FormSwitched && i < this.GetSetting(eSettings.NavigationMaximum, 10));
+
+        //}
+
+        /// <summary>
+        /// This method will update all local created bot commands to the botfather.
+        /// </summary>
+        public async Task UploadBotCommands()
         {
-            DeviceSession ds = e.Device;
+            await this.Client.SetBotCommands(this.BotCommands);
-            if (ds == null)
-            {
-                ds = await this.Sessions.StartSession<T>(e.DeviceId);
-                e.Device = ds;
-            }
-
-            ds.ChatTitle = e.Message.Chat.Username ?? e.Message.Chat.Title;
-            ds.LastAction = DateTime.Now;
-            ds.LastMessage = e.Message;
-
-            FormBase activeForm = null;
-
-            int i = 0;
-
-            //Should formulars get navigated (allow maximum of 10, to dont get loops)
-            do
-            {
-                i++;
-
-                //Reset navigation
-                ds.FormSwitched = false;
-
-                activeForm = ds.ActiveForm;
-
-                //Pre Loading Event
-                await activeForm.PreLoad(e);
-
-                //Send Load event to controls
-                await activeForm.LoadControls(e);
-
-                //Loading Event
-                await activeForm.Load(e);
-
-                //Action Event
-                if (!ds.FormSwitched)
-                {
-                    //Send Action event to controls
-                    await activeForm.ActionControls(e);
-
-                    //Send Action event to form itself
-                    await activeForm.Action(e);
-
-                    if (!e.Handled)
-                    {
-                        var uhc = new UnhandledCallEventArgs(e.Message.Text, e.RawData, ds.DeviceId, e.MessageId, e.Message, ds);
-                        OnUnhandledCall(uhc);
-
-                        if (uhc.Handled)
-                        {
-                            if (ds.FormSwitched)
-                            {
-                                continue;
-                            }
-                            else
-                            {
-                                break;
-                            }
-                        }
-                    }
-
-                }
-
-                //Render Event
-                if (!ds.FormSwitched)
-                {
-                    await activeForm.RenderControls(e);
-
-                    await activeForm.Render(e);
-                }
-
-                e.IsFirstHandler = false;
-
-            } while (ds.FormSwitched && i < NavigationMaximum);
-
         }
 
+        /// <summary>
+        /// Could set a variety of settings to improve the bot handling.
+        /// </summary>
+        /// <param name="set"></param>
+        /// <param name="Value"></param>
+        public void SetSetting(eSettings set, uint Value)
+        {
+            this.SystemSettings[set] = Value;
+        }
+
+        /// <summary>
+        /// Could set a variety of settings to improve the bot handling.
+        /// </summary>
+        /// <param name="set"></param>
+        /// <param name="Value"></param>
+        public void SetSetting(eSettings set, bool Value)
+        {
+            this.SystemSettings[set] = (Value ? 1u : 0u);
+        }
+
+        /// <summary>
+        /// Could get the current value of a setting
+        /// </summary>
+        /// <param name="set"></param>
+        /// <param name="defaultValue"></param>
+        /// <returns></returns>
+        public uint GetSetting(eSettings set, uint defaultValue)
+        {
+            if (!this.SystemSettings.ContainsKey(set))
+                return defaultValue;
+
+            return this.SystemSettings[set];
+        }
+
+        /// <summary>
+        /// Could get the current value of a setting
+        /// </summary>
+        /// <param name="set"></param>
+        /// <param name="defaultValue"></param>
+        /// <returns></returns>
+        public bool GetSetting(eSettings set, bool defaultValue)
+        {
+            if (!this.SystemSettings.ContainsKey(set))
+                return defaultValue;
+
+            return this.SystemSettings[set] == 0u ? false : true;
+        }
+
+        #region "Events"
+
         /// <summary>
         /// Will be called if a session/context gets started
         /// </summary>
@@ -518,15 +699,15 @@ namespace TelegramBotBase
         }
 
         /// <summary>
-        /// Will be called if a system call gets raised
+        /// Will be called if a bot command gets raised
         /// </summary>
-        public event SystemCallEventHandler SystemCall;
+        public event BotCommandEventHandler BotCommand;
 
 
-        public async Task OnSystemCall(SystemCallEventArgs e)
+        public async Task OnBotCommand(BotCommandEventArgs e)
         {
-            if (this.SystemCall != null)
+            if (this.BotCommand != null)
-                await SystemCall(this, e);
+                await BotCommand(this, e);
         }
 
         /// <summary>
@@ -570,5 +751,8 @@ namespace TelegramBotBase
             (this.__Events[__evUnhandledCall] as EventHandler<UnhandledCallEventArgs>)?.Invoke(this, e);
 
         }
+
+        #endregion
+
     }
 }

TelegramBotBase/Commands/Extensions.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Telegram.Bot.Types;
+
+namespace TelegramBotBase.Commands
+{
+    public static class Extensions
+    {
+        /// <summary>
+        /// Adding the default /start command with a description.
+        /// </summary>
+        /// <param name="cmds"></param>
+        /// <param name="description"></param>
+        public static void AddStartCommand(this List<BotCommand> cmds, String description)
+        {
+            cmds.Add(new BotCommand() { Command = "start", Description = description });
+        }
+
+        /// <summary>
+        /// Adding the default /help command with a description.
+        /// </summary>
+        /// <param name="cmds"></param>
+        /// <param name="description"></param>
+        public static void AddHelpCommand(this List<BotCommand> cmds, String description)
+        {
+            cmds.Add(new BotCommand() { Command = "help", Description = description });
+        }
+
+        /// <summary>
+        /// Adding the default /settings command with a description.
+        /// </summary>
+        /// <param name="cmds"></param>
+        /// <param name="description"></param>
+        public static void AddSettingsCommand(this List<BotCommand> cmds, String description)
+        {
+            cmds.Add(new BotCommand() { Command = "settings", Description = description });
+        }
+    }
+}

TelegramBotBase/Constants/Telegram.cs

@@ -21,5 +21,7 @@ namespace TelegramBotBase.Constants
 
         public const int MaxReplyKeyboardCols = 12;
 
+        public const int MessageDeletionsPerSecond = 30;
+
     }
 }

TelegramBotBase/Controls/ButtonGrid.cs

@@ -1,308 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Telegram.Bot.Types;
-using Telegram.Bot.Types.Enums;
-using Telegram.Bot.Types.ReplyMarkups;
-using TelegramBotBase.Args;
-using TelegramBotBase.Base;
-using TelegramBotBase.Enums;
-using TelegramBotBase.Exceptions;
-using TelegramBotBase.Form;
-
-namespace TelegramBotBase.Controls
-{
-    public class ButtonGrid : Base.ControlBase
-    {
-
-        public String Title { get; set; } = "Toggle";
-
-        public String ConfirmationText { get; set; } = "";
-
-        private bool RenderNecessary = true;
-
-        private static readonly object __evButtonClicked = new object();
-
-        private readonly EventHandlerList Events = new EventHandlerList();
-
-        public ButtonForm ButtonsForm { get; set; }
-
-        public int? MessageId { get; set; }
-
-
-        /// <summary>
-        /// Optional. Requests clients to resize the keyboard vertically for optimal fit (e.g., make the keyboard smaller if there are just two rows of buttons). Defaults to false, in which case the custom keyboard is always of the same height as the app's standard keyboard.
-        /// Source: https://core.telegram.org/bots/api#replykeyboardmarkup
-        /// </summary>
-        public bool ResizeKeyboard { get; set; } = false;
-
-        public bool OneTimeKeyboard { get; set; } = false;
-
-        public bool HideKeyboardOnCleanup { get; set; } = true;
-
-        public bool DeletePreviousMessage { get; set; } = true;
-
-        public ParseMode MessageParseMode { get; set; } = ParseMode.Default;
-
-        /// <summary>
-        /// Defines which type of Button Keyboard should be rendered.
-        /// </summary>
-        public eKeyboardType KeyboardType
-        {
-            get
-            {
-                return m_eKeyboardType;
-            }
-            set
-            {
-                if (m_eKeyboardType != value)
-                {
-                    this.RenderNecessary = true;
-
-                    Cleanup().Wait();
-
-                    m_eKeyboardType = value;
-                }
-
-            }
-        }
-
-        private eKeyboardType m_eKeyboardType = eKeyboardType.ReplyKeyboard;
-
-        public ButtonGrid()
-        {
-            this.ButtonsForm = new ButtonForm();
-
-
-        }
-
-        public ButtonGrid(eKeyboardType type) : this()
-        {
-            m_eKeyboardType = type;
-        }
-
-
-        public ButtonGrid(ButtonForm form)
-        {
-            this.ButtonsForm = form;
-        }
-
-
-        public event EventHandler<ButtonClickedEventArgs> ButtonClicked
-        {
-            add
-            {
-                this.Events.AddHandler(__evButtonClicked, value);
-            }
-            remove
-            {
-                this.Events.RemoveHandler(__evButtonClicked, value);
-            }
-        }
-
-        public void OnButtonClicked(ButtonClickedEventArgs e)
-        {
-            (this.Events[__evButtonClicked] as EventHandler<ButtonClickedEventArgs>)?.Invoke(this, e);
-        }
-
-        public async override Task Load(MessageResult result)
-        {
-            if (this.KeyboardType != eKeyboardType.ReplyKeyboard)
-                return;
-
-            if (!result.IsFirstHandler)
-                return;
-
-            var button = ButtonsForm.ToList().FirstOrDefault(a => a.Text.Trim() == result.MessageText);
-
-            if (button == null)
-                return;
-
-            OnButtonClicked(new ButtonClickedEventArgs(button));
-
-            //Remove button click message
-            if (this.DeletePreviousMessage)
-                await Device.DeleteMessage(result.MessageId);
-
-            result.Handled = true;
-
-        }
-
-        public async override Task Action(MessageResult result, string value = null)
-        {
-            if (result.Handled)
-                return;
-
-            if (!result.IsFirstHandler)
-                return;
-
-            await result.ConfirmAction(this.ConfirmationText ?? "");
-
-            //Find clicked button depending on Text or Value (depending on markup type)
-            switch (this.KeyboardType)
-            {
-                case eKeyboardType.InlineKeyBoard:
-
-                    var button = ButtonsForm.ToList().FirstOrDefault(a => a.Value == result.RawData);
-
-                    if (button == null)
-                        return;
-
-                    OnButtonClicked(new ButtonClickedEventArgs(button));
-
-                    result.Handled = true;
-
-                    break;
-            }
-
-        }
-
-        public async override Task Render(MessageResult result)
-        {
-            if (!this.RenderNecessary)
-                return;
-
-
-            switch (m_eKeyboardType)
-            {
-                case eKeyboardType.InlineKeyBoard:
-
-                    if (ButtonsForm.Rows > Constants.Telegram.MaxInlineKeyBoardRows)
-                    {
-                        throw new MaximumRowsReachedException() { Value = ButtonsForm.Rows, Maximum = Constants.Telegram.MaxInlineKeyBoardRows };
-                    }
-
-                    if (ButtonsForm.Cols > Constants.Telegram.MaxInlineKeyBoardCols)
-                    {
-                        throw new MaximumColsException() { Value = ButtonsForm.Rows, Maximum = Constants.Telegram.MaxInlineKeyBoardCols };
-                    }
-
-                    break;
-                case eKeyboardType.ReplyKeyboard:
-
-                    if (ButtonsForm.Rows > Constants.Telegram.MaxReplyKeyboardRows)
-                    {
-                        throw new MaximumRowsReachedException() { Value = ButtonsForm.Rows, Maximum = Constants.Telegram.MaxReplyKeyboardRows };
-                    }
-
-                    if (ButtonsForm.Cols > Constants.Telegram.MaxReplyKeyboardCols)
-                    {
-                        throw new MaximumColsException() { Value = ButtonsForm.Rows, Maximum = Constants.Telegram.MaxReplyKeyboardCols };
-                    }
-
-                    break;
-            }
-
-            Message m = null;
-            if (this.MessageId != null)
-            {
-                switch (this.KeyboardType)
-                {
-                    //Reply Keyboard could only be updated with a new keyboard.
-                    case eKeyboardType.ReplyKeyboard:
-                        if (this.ButtonsForm.Count == 0)
-                        {
-                            await this.Device.HideReplyKeyboard();
-                            this.MessageId = null;
-                        }
-                        else
-                        {
-                            if (this.DeletePreviousMessage)
-                                await this.Device.DeleteMessage(this.MessageId.Value);
-
-                            var rkm = (ReplyKeyboardMarkup)this.ButtonsForm;
-                            rkm.ResizeKeyboard = this.ResizeKeyboard;
-                            rkm.OneTimeKeyboard = this.OneTimeKeyboard;
-                            m = await this.Device.Send(this.Title, rkm, disableNotification: true, parseMode: MessageParseMode);
-                        }
-
-                        break;
-
-                    case eKeyboardType.InlineKeyBoard:
-                        m = await this.Device.Edit(this.MessageId.Value, this.Title, (InlineKeyboardMarkup)this.ButtonsForm);
-                        break;
-                }
-
-
-            }
-            else
-            {
-                switch (this.KeyboardType)
-                {
-                    case eKeyboardType.ReplyKeyboard:
-                        var rkm = (ReplyKeyboardMarkup)this.ButtonsForm;
-                        rkm.ResizeKeyboard = this.ResizeKeyboard;
-                        rkm.OneTimeKeyboard = this.OneTimeKeyboard;
-                        m = await this.Device.Send(this.Title, rkm, disableNotification: true, parseMode: MessageParseMode);
-                        break;
-
-                    case eKeyboardType.InlineKeyBoard:
-                        m = await this.Device.Send(this.Title, (InlineKeyboardMarkup)this.ButtonsForm, disableNotification: true, parseMode: MessageParseMode);
-                        break;
-                }
-
-                if (m != null)
-                {
-                    this.MessageId = m.MessageId;
-                }
-            }
-
-            this.RenderNecessary = false;
-
-        }
-
-        public override async Task Hidden(bool FormClose)
-        {
-            //Prepare for opening Modal, and comming back
-            if (!FormClose)
-            {
-                this.Updated();
-            }
-        }
-
-        /// <summary>
-        /// Tells the control that it has been updated.
-        /// </summary>
-        public void Updated()
-        {
-            this.RenderNecessary = true;
-        }
-
-        public async override Task Cleanup()
-        {
-            if (this.MessageId == null)
-                return;
-
-            switch (this.KeyboardType)
-            {
-                case eKeyboardType.InlineKeyBoard:
-
-                    await this.Device.DeleteMessage(this.MessageId.Value);
-
-                    this.MessageId = null;
-
-                    break;
-                case eKeyboardType.ReplyKeyboard:
-
-                    if (this.HideKeyboardOnCleanup)
-                    {
-                        await this.Device.HideReplyKeyboard();
-                    }
-
-                    this.MessageId = null;
-
-                    break;
-            }
-
-
-
-
-        }
-
-    }
-
-
-}

TelegramBotBase/Controls/Hybrid/ButtonGrid.cs

@@ -0,0 +1,738 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.SymbolStore;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+using Telegram.Bot.Types.ReplyMarkups;
+using TelegramBotBase.Args;
+using TelegramBotBase.Base;
+using TelegramBotBase.Datasources;
+using TelegramBotBase.Enums;
+using TelegramBotBase.Exceptions;
+using TelegramBotBase.Form;
+using static TelegramBotBase.Base.Async;
+
+namespace TelegramBotBase.Controls.Hybrid
+{
+    public class ButtonGrid : Base.ControlBase
+    {
+
+        public String Title { get; set; } = Localizations.Default.Language["ButtonGrid_Title"];
+
+        public String ConfirmationText { get; set; } = "";
+
+        private bool RenderNecessary = true;
+
+        private static readonly object __evButtonClicked = new object();
+
+        private readonly EventHandlerList Events = new EventHandlerList();
+
+        /// <summary>
+        /// 
+        /// </summary>
+        [Obsolete("This property is obsolete. Please use the DataSource property instead.")]
+        public ButtonForm ButtonsForm
+        {
+            get
+            {
+                return DataSource.ButtonForm;
+            }
+            set
+            {
+                DataSource = new ButtonFormDataSource(value);
+            }
+        }
+
+        /// <summary>
+        /// Data source of the items.
+        /// </summary>
+        public ButtonFormDataSource DataSource { get; set; }
+
+        public int? MessageId { get; set; }
+
+
+        /// <summary>
+        /// Optional. Requests clients to resize the keyboard vertically for optimal fit (e.g., make the keyboard smaller if there are just two rows of buttons). Defaults to false, in which case the custom keyboard is always of the same height as the app's standard keyboard.
+        /// Source: https://core.telegram.org/bots/api#replykeyboardmarkup
+        /// </summary>
+        public bool ResizeKeyboard { get; set; } = false;
+
+        public bool OneTimeKeyboard { get; set; } = false;
+
+        public bool HideKeyboardOnCleanup { get; set; } = true;
+
+        public bool DeletePreviousMessage { get; set; } = true;
+
+        /// <summary>
+        /// Removes the reply message from a user.
+        /// </summary>
+        public bool DeleteReplyMessage { get; set; } = true;
+
+        /// <summary>
+        /// Parsemode of the message.
+        /// </summary>
+        public ParseMode MessageParseMode { get; set; } = ParseMode.Default;
+
+        /// <summary>
+        /// Enables automatic paging of buttons when the amount of rows is exceeding the limits.
+        /// </summary>
+        public bool EnablePaging { get; set; } = false;
+
+
+        /// <summary>
+        /// Enabled a search function.
+        /// </summary>
+        public bool EnableSearch { get; set; } = false;
+
+        public String SearchQuery { get; set; }
+
+        public eNavigationBarVisibility NavigationBarVisibility { get; set; } = eNavigationBarVisibility.always;
+
+
+        /// <summary>
+        /// Index of the current page
+        /// </summary>
+        public int CurrentPageIndex { get; set; } = 0;
+
+        public String PreviousPageLabel = Localizations.Default.Language["ButtonGrid_PreviousPage"];
+
+        public String NextPageLabel = Localizations.Default.Language["ButtonGrid_NextPage"];
+
+        public String NoItemsLabel = Localizations.Default.Language["ButtonGrid_NoItems"];
+
+        public String SearchLabel = Localizations.Default.Language["ButtonGrid_SearchFeature"];
+
+        /// <summary>
+        /// Layout of the buttons which should be displayed always on top.
+        /// </summary>
+        public ButtonRow HeadLayoutButtonRow { get; set; }
+
+        /// <summary>
+        /// Layout of columns which should be displayed below the header
+        /// </summary>
+        public ButtonRow SubHeadLayoutButtonRow { get; set; }
+
+        /// <summary>
+        /// Defines which type of Button Keyboard should be rendered.
+        /// </summary>
+        public eKeyboardType KeyboardType
+        {
+            get
+            {
+                return m_eKeyboardType;
+            }
+            set
+            {
+                if (m_eKeyboardType != value)
+                {
+                    this.RenderNecessary = true;
+
+                    Cleanup().Wait();
+
+                    m_eKeyboardType = value;
+                }
+
+            }
+        }
+
+        private eKeyboardType m_eKeyboardType = eKeyboardType.ReplyKeyboard;
+
+        public ButtonGrid()
+        {
+            this.DataSource = new ButtonFormDataSource();
+
+        }
+
+        public ButtonGrid(eKeyboardType type) : this()
+        {
+            m_eKeyboardType = type;
+        }
+
+
+        public ButtonGrid(ButtonForm form)
+        {
+            this.DataSource = new ButtonFormDataSource(form);
+        }
+
+
+        public event AsyncEventHandler<ButtonClickedEventArgs> ButtonClicked
+        {
+            add
+            {
+                this.Events.AddHandler(__evButtonClicked, value);
+            }
+            remove
+            {
+                this.Events.RemoveHandler(__evButtonClicked, value);
+            }
+        }
+
+        public async Task OnButtonClicked(ButtonClickedEventArgs e)
+        {
+            var handler = this.Events[__evButtonClicked]?.GetInvocationList().Cast<AsyncEventHandler<ButtonClickedEventArgs>>();
+            if (handler == null)
+                return;
+
+            foreach (var h in handler)
+            {
+                await Async.InvokeAllAsync<ButtonClickedEventArgs>(h, this, e);
+            }
+        }
+
+        public override void Init()
+        {
+            this.Device.MessageDeleted += Device_MessageDeleted;
+        }
+
+        private void Device_MessageDeleted(object sender, MessageDeletedEventArgs e)
+        {
+            if (this.MessageId == null)
+                return;
+
+            if (e.MessageId != this.MessageId)
+                return;
+
+            this.MessageId = null;
+        }
+
+        public async override Task Load(MessageResult result)
+        {
+            if (this.KeyboardType != eKeyboardType.ReplyKeyboard)
+                return;
+
+            if (!result.IsFirstHandler)
+                return;
+
+            if (result.MessageText == null || result.MessageText == "")
+                return;
+
+            var matches = new List<ButtonRow>();
+            ButtonRow match = null;
+            int index = -1;
+
+            if (HeadLayoutButtonRow?.Matches(result.MessageText) ?? false)
+            {
+                match = HeadLayoutButtonRow;
+                goto check;
+            }
+
+            if (SubHeadLayoutButtonRow?.Matches(result.MessageText) ?? false)
+            {
+                match = SubHeadLayoutButtonRow;
+                goto check;
+            }
+
+            var br = DataSource.FindRow(result.MessageText);
+            if (br != null)
+            {
+                match = br.Item1;
+                index = br.Item2;
+            }
+
+
+        //var button = HeadLayoutButtonRow?. .FirstOrDefault(a => a.Text.Trim() == result.MessageText)
+        //            ?? SubHeadLayoutButtonRow?.FirstOrDefault(a => a.Text.Trim() == result.MessageText);
+
+        // bf.ToList().FirstOrDefault(a => a.Text.Trim() == result.MessageText)
+
+        //var index = bf.FindRowByButton(button);
+
+        check:
+
+            //Remove button click message
+            if (this.DeleteReplyMessage)
+                await Device.DeleteMessage(result.MessageId);
+
+            if (match != null)
+            {
+                await OnButtonClicked(new ButtonClickedEventArgs(match.GetButtonMatch(result.MessageText), index, match));
+
+                result.Handled = true;
+                return;
+            }
+
+
+            if (result.MessageText == PreviousPageLabel)
+            {
+                if (this.CurrentPageIndex > 0)
+                    this.CurrentPageIndex--;
+
+                this.Updated();
+            }
+            else if (result.MessageText == NextPageLabel)
+            {
+                if (this.CurrentPageIndex < this.PageCount - 1)
+                    this.CurrentPageIndex++;
+
+                this.Updated();
+            }
+            else if (this.EnableSearch)
+            {
+                if (result.MessageText.StartsWith("🔍"))
+                {
+                    //Sent note about searching
+                    if (this.SearchQuery == null)
+                    {
+                        await this.Device.Send(this.SearchLabel);
+                    }
+
+                    this.SearchQuery = null;
+                    this.Updated();
+                    return;
+                }
+
+                this.SearchQuery = result.MessageText;
+
+                if (this.SearchQuery != null && this.SearchQuery != "")
+                {
+                    this.CurrentPageIndex = 0;
+                    this.Updated();
+                }
+
+            }
+
+
+
+        }
+
+        public async override Task Action(MessageResult result, string value = null)
+        {
+            if (result.Handled)
+                return;
+
+            if (!result.IsFirstHandler)
+                return;
+
+            //Find clicked button depending on Text or Value (depending on markup type)
+            if (this.KeyboardType != eKeyboardType.InlineKeyBoard)
+                return;
+
+            await result.ConfirmAction(this.ConfirmationText ?? "");
+
+            ButtonRow match = null;
+            int index = -1;
+
+            if (HeadLayoutButtonRow?.Matches(result.RawData, false) ?? false)
+            {
+                match = HeadLayoutButtonRow;
+                goto check;
+            }
+
+            if (SubHeadLayoutButtonRow?.Matches(result.RawData, false) ?? false)
+            {
+                match = SubHeadLayoutButtonRow;
+                goto check;
+            }
+
+            var br = DataSource.FindRow(result.RawData, false);
+            if (br != null)
+            {
+                match = br.Item1;
+                index = br.Item2;
+            }
+
+
+
+        //var bf = DataSource.ButtonForm;
+
+        //var button = HeadLayoutButtonRow?.FirstOrDefault(a => a.Value == result.RawData)
+        //            ?? SubHeadLayoutButtonRow?.FirstOrDefault(a => a.Value == result.RawData)
+        //            ?? bf.ToList().FirstOrDefault(a => a.Value == result.RawData);
+
+        //var index = bf.FindRowByButton(button);
+
+        check:
+            if (match != null)
+            {
+                await OnButtonClicked(new ButtonClickedEventArgs(match.GetButtonMatch(result.RawData, false), index, match));
+
+                result.Handled = true;
+                return;
+            }
+
+            switch (result.RawData)
+            {
+                case "$previous$":
+
+                    if (this.CurrentPageIndex > 0)
+                        this.CurrentPageIndex--;
+
+                    this.Updated();
+
+                    break;
+                case "$next$":
+
+                    if (this.CurrentPageIndex < this.PageCount - 1)
+                        this.CurrentPageIndex++;
+
+                    this.Updated();
+
+                    break;
+            }
+
+        }
+
+        /// <summary>
+        /// This method checks of the amount of buttons
+        /// </summary>
+        private void CheckGrid()
+        {
+            switch (m_eKeyboardType)
+            {
+                case eKeyboardType.InlineKeyBoard:
+
+                    if (DataSource.RowCount > Constants.Telegram.MaxInlineKeyBoardRows && !this.EnablePaging)
+                    {
+                        throw new MaximumRowsReachedException() { Value = DataSource.RowCount, Maximum = Constants.Telegram.MaxInlineKeyBoardRows };
+                    }
+
+                    if (DataSource.ColumnCount > Constants.Telegram.MaxInlineKeyBoardCols)
+                    {
+                        throw new MaximumColsException() { Value = DataSource.ColumnCount, Maximum = Constants.Telegram.MaxInlineKeyBoardCols };
+                    }
+
+                    break;
+
+                case eKeyboardType.ReplyKeyboard:
+
+                    if (DataSource.RowCount > Constants.Telegram.MaxReplyKeyboardRows && !this.EnablePaging)
+                    {
+                        throw new MaximumRowsReachedException() { Value = DataSource.RowCount, Maximum = Constants.Telegram.MaxReplyKeyboardRows };
+                    }
+
+                    if (DataSource.ColumnCount > Constants.Telegram.MaxReplyKeyboardCols)
+                    {
+                        throw new MaximumColsException() { Value = DataSource.ColumnCount, Maximum = Constants.Telegram.MaxReplyKeyboardCols };
+                    }
+
+                    break;
+            }
+        }
+
+        public async override Task Render(MessageResult result)
+        {
+            if (!this.RenderNecessary)
+                return;
+
+            //Check for rows and column limits
+            CheckGrid();
+
+            this.RenderNecessary = false;
+
+            ButtonForm form = this.DataSource.PickItems(CurrentPageIndex * ItemRowsPerPage, ItemRowsPerPage, (this.EnableSearch ? this.SearchQuery : null));
+
+
+            //if (this.EnableSearch && this.SearchQuery != null && this.SearchQuery != "")
+            //{
+            //    form = form.FilterDuplicate(this.SearchQuery, true);
+            //}
+            //else
+            //{
+            //    form = form.Duplicate();
+            //}
+
+            if (this.EnablePaging)
+            {
+                IntegratePagingView(form);
+            }
+
+            if (this.HeadLayoutButtonRow != null && HeadLayoutButtonRow.Count > 0)
+            {
+                form.InsertButtonRow(0, this.HeadLayoutButtonRow);
+            }
+
+            if (this.SubHeadLayoutButtonRow != null && SubHeadLayoutButtonRow.Count > 0)
+            {
+                if (this.IsNavigationBarVisible)
+                {
+                    form.InsertButtonRow(2, this.SubHeadLayoutButtonRow);
+                }
+                else
+                {
+                    form.InsertButtonRow(1, this.SubHeadLayoutButtonRow);
+                }
+            }
+
+            Message m = null;
+
+            switch (this.KeyboardType)
+            {
+                //Reply Keyboard could only be updated with a new keyboard.
+                case eKeyboardType.ReplyKeyboard:
+
+
+                    if (form.Count == 0)
+                    {
+                        if (this.MessageId != null)
+                        {
+                            await this.Device.HideReplyKeyboard();
+                            this.MessageId = null;
+                        }
+
+                        return;
+                    }
+
+                    //if (this.MessageId != null)
+                    //{
+                    //    if (form.Count == 0)
+                    //    {
+                    //        await this.Device.HideReplyKeyboard();
+                    //        this.MessageId = null;
+                    //        return;
+                    //    }
+                    //}
+
+                    //if (form.Count == 0)
+                    //    return;
+
+
+                    var rkm = (ReplyKeyboardMarkup)form;
+                    rkm.ResizeKeyboard = this.ResizeKeyboard;
+                    rkm.OneTimeKeyboard = this.OneTimeKeyboard;
+                    m = await this.Device.Send(this.Title, rkm, disableNotification: true, parseMode: MessageParseMode, MarkdownV2AutoEscape: false);
+
+                    //Prevent flicker of keyboard
+                    if (this.DeletePreviousMessage && this.MessageId != null)
+                        await this.Device.DeleteMessage(this.MessageId.Value);
+
+                    break;
+
+                case eKeyboardType.InlineKeyBoard:
+
+                    //Try to edit message if message id is available
+                    //When the returned message is null then the message has been already deleted, resend it
+                    if (this.MessageId != null)
+                    {
+                        m = await this.Device.Edit(this.MessageId.Value, this.Title, (InlineKeyboardMarkup)form);
+                        if (m != null)
+                        {
+                            this.MessageId = m.MessageId;
+                            return;
+                        }
+                    }
+
+                    //When no message id is available or it has been deleted due the use of AutoCleanForm re-render automatically
+                    m = await this.Device.Send(this.Title, (InlineKeyboardMarkup)form, disableNotification: true, parseMode: MessageParseMode, MarkdownV2AutoEscape: false);
+
+                    break;
+            }
+
+            if (m != null)
+            {
+                this.MessageId = m.MessageId;
+            }
+
+
+        }
+
+        private void IntegratePagingView(ButtonForm dataForm)
+        {
+            //No Items 
+            if (dataForm.Rows == 0)
+            {
+                dataForm.AddButtonRow(new ButtonBase(NoItemsLabel, "$"));
+            }
+
+            if (this.IsNavigationBarVisible)
+            {
+                //🔍
+                ButtonRow row = new ButtonRow();
+                row.Add(new ButtonBase(PreviousPageLabel, "$previous$"));
+                row.Add(new ButtonBase(String.Format(Localizations.Default.Language["ButtonGrid_CurrentPage"], this.CurrentPageIndex + 1, this.PageCount), "$site$"));
+                row.Add(new ButtonBase(NextPageLabel, "$next$"));
+
+                if (this.EnableSearch)
+                {
+                    row.Insert(2, new ButtonBase("🔍 " + (this.SearchQuery ?? ""), "$search$"));
+                }
+
+                dataForm.InsertButtonRow(0, row);
+
+                dataForm.AddButtonRow(row);
+            }
+        }
+
+        public bool PagingNecessary
+        {
+            get
+            {
+                if (this.KeyboardType == eKeyboardType.InlineKeyBoard && TotalRows > Constants.Telegram.MaxInlineKeyBoardRows)
+                {
+                    return true;
+                }
+
+                if (this.KeyboardType == eKeyboardType.ReplyKeyboard && TotalRows > Constants.Telegram.MaxReplyKeyboardRows)
+                {
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        public bool IsNavigationBarVisible
+        {
+            get
+            {
+                if (this.NavigationBarVisibility == eNavigationBarVisibility.always | (this.NavigationBarVisibility == eNavigationBarVisibility.auto && PagingNecessary))
+                {
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Returns the maximum number of rows
+        /// </summary>
+        public int MaximumRow
+        {
+            get
+            {
+                switch (this.KeyboardType)
+                {
+                    case eKeyboardType.InlineKeyBoard:
+                        return Constants.Telegram.MaxInlineKeyBoardRows;
+
+                    case eKeyboardType.ReplyKeyboard:
+                        return Constants.Telegram.MaxReplyKeyboardRows;
+
+                    default:
+                        return 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns the number of all rows (layout + navigation + content);
+        /// </summary>
+        public int TotalRows
+        {
+            get
+            {
+                return this.LayoutRows + DataSource.RowCount;
+            }
+        }
+
+
+        /// <summary>
+        /// Contains the Number of Rows which are used by the layout.
+        /// </summary>
+        private int LayoutRows
+        {
+            get
+            {
+                int layoutRows = 0;
+
+                if (this.NavigationBarVisibility == eNavigationBarVisibility.always | this.NavigationBarVisibility == eNavigationBarVisibility.auto)
+                    layoutRows += 2;
+
+                if (this.HeadLayoutButtonRow != null && this.HeadLayoutButtonRow.Count > 0)
+                    layoutRows++;
+
+                if (this.SubHeadLayoutButtonRow != null && this.SubHeadLayoutButtonRow.Count > 0)
+                    layoutRows++;
+
+                return layoutRows;
+            }
+        }
+
+        /// <summary>
+        /// Returns the number of item rows per page.
+        /// </summary>
+        public int ItemRowsPerPage
+        {
+            get
+            {
+                return this.MaximumRow - this.LayoutRows;
+            }
+        }
+
+        /// <summary>
+        /// Return the number of pages.
+        /// </summary>
+        public int PageCount
+        {
+            get
+            {
+                if (DataSource.RowCount == 0)
+                    return 1;
+
+                //var bf = this.DataSource.PickAllItems(this.EnableSearch ? this.SearchQuery : null);
+
+                var max = this.DataSource.CalculateMax(this.EnableSearch ? this.SearchQuery : null);
+
+                //if (this.EnableSearch && this.SearchQuery != null && this.SearchQuery != "")
+                //{
+                //    bf = bf.FilterDuplicate(this.SearchQuery);
+                //}
+
+                if (max == 0)
+                    return 1;
+
+                return (int)Math.Ceiling((decimal)((decimal)max / (decimal)ItemRowsPerPage));
+            }
+        }
+
+        public override async Task Hidden(bool FormClose)
+        {
+            //Prepare for opening Modal, and comming back
+            if (!FormClose)
+            {
+                this.Updated();
+            }
+            else
+            {
+                //Remove event handler
+                this.Device.MessageDeleted -= Device_MessageDeleted;
+            }
+        }
+
+        /// <summary>
+        /// Tells the control that it has been updated.
+        /// </summary>
+        public void Updated()
+        {
+            this.RenderNecessary = true;
+        }
+
+        public async override Task Cleanup()
+        {
+            if (this.MessageId == null)
+                return;
+
+            switch (this.KeyboardType)
+            {
+                case eKeyboardType.InlineKeyBoard:
+
+                    await this.Device.DeleteMessage(this.MessageId.Value);
+
+                    this.MessageId = null;
+
+                    break;
+                case eKeyboardType.ReplyKeyboard:
+
+                    if (this.HideKeyboardOnCleanup)
+                    {
+                        await this.Device.HideReplyKeyboard();
+                    }
+
+                    this.MessageId = null;
+
+                    break;
+            }
+
+
+
+
+        }
+
+    }
+
+
+}

TelegramBotBase/Controls/Hybrid/ButtonRow.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Controls.Hybrid
+{
+    [DebuggerDisplay("{Count} columns")]
+    public class ButtonRow
+    {
+
+        List<ButtonBase> __buttons = new List<ButtonBase>();
+
+        public ButtonRow()
+        {
+
+
+        }
+
+        public ButtonRow(params ButtonBase[] buttons)
+        {
+            __buttons = buttons.ToList();
+        }
+
+
+        public ButtonBase this[int index]
+        {
+            get
+            {
+                return __buttons[index];
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                return __buttons.Count;
+            }
+        }
+
+        public void Add(ButtonBase button)
+        {
+            __buttons.Add(button);
+        }
+
+        public void AddRange(ButtonBase button)
+        {
+            __buttons.Add(button);
+        }
+
+        public void Insert(int index, ButtonBase button)
+        {
+            __buttons.Insert(index, button);
+        }
+
+        public IEnumerator<ButtonBase> GetEnumerator()
+        {
+            return __buttons.GetEnumerator();
+        }
+
+        public ButtonBase[] ToArray()
+        {
+            return __buttons.ToArray();
+        }
+
+        public List<ButtonBase> ToList()
+        {
+            return __buttons.ToList();
+        }
+
+        public bool Matches(String text, bool useText = true)
+        {
+            foreach (var b in __buttons)
+            {
+                if (useText && b.Text.Trim().Equals(text, StringComparison.InvariantCultureIgnoreCase))
+                    return true;
+
+                if (!useText && b.Value.Equals(text, StringComparison.InvariantCultureIgnoreCase))
+                    return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Returns the button inside of the row which matches.
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="useText"></param>
+        /// <returns></returns>
+        public ButtonBase GetButtonMatch(String text, bool useText = true)
+        {
+            foreach (var b in __buttons)
+            {
+                if (useText && b.Text.Trim().Equals(text, StringComparison.InvariantCultureIgnoreCase))
+                    return b;
+                if (!useText && b.Value.Equals(text, StringComparison.InvariantCultureIgnoreCase))
+                    return b;
+            }
+            return null;
+        }
+
+        public static implicit operator ButtonRow(List<ButtonBase> list)
+        {
+            return new ButtonRow() { __buttons = list };
+        }
+    }
+}

TelegramBotBase/Controls/Hybrid/CheckedButtonList.cs

@@ -0,0 +1,874 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.SymbolStore;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+using Telegram.Bot.Types.ReplyMarkups;
+using TelegramBotBase.Args;
+using TelegramBotBase.Base;
+using TelegramBotBase.Datasources;
+using TelegramBotBase.Enums;
+using TelegramBotBase.Exceptions;
+using TelegramBotBase.Form;
+using static TelegramBotBase.Base.Async;
+
+namespace TelegramBotBase.Controls.Hybrid
+{
+    public class CheckedButtonList : Base.ControlBase
+    {
+
+        public String Title { get; set; } = Localizations.Default.Language["ButtonGrid_Title"];
+
+        public String ConfirmationText { get; set; } = "";
+
+        private bool RenderNecessary = true;
+
+        private static readonly object __evButtonClicked = new object();
+
+        private static readonly object __evCheckedChanged = new object();
+
+        private readonly EventHandlerList Events = new EventHandlerList();
+
+        [Obsolete("This property is obsolete. Please use the DataSource property instead.")]
+        public ButtonForm ButtonsForm
+        {
+            get
+            {
+                return DataSource.ButtonForm;
+            }
+            set
+            {
+                DataSource = new ButtonFormDataSource(value);
+            }
+        }
+
+        /// <summary>
+        /// Data source of the items.
+        /// </summary>
+        public ButtonFormDataSource DataSource { get; set; }
+
+        List<int> CheckedRows { get; set; } = new List<int>();
+
+        public int? MessageId { get; set; }
+
+
+        /// <summary>
+        /// Optional. Requests clients to resize the keyboard vertically for optimal fit (e.g., make the keyboard smaller if there are just two rows of buttons). Defaults to false, in which case the custom keyboard is always of the same height as the app's standard keyboard.
+        /// Source: https://core.telegram.org/bots/api#replykeyboardmarkup
+        /// </summary>
+        public bool ResizeKeyboard { get; set; } = false;
+
+        public bool OneTimeKeyboard { get; set; } = false;
+
+        public bool HideKeyboardOnCleanup { get; set; } = true;
+
+        public bool DeletePreviousMessage { get; set; } = true;
+
+        /// <summary>
+        /// Removes the reply message from a user.
+        /// </summary>
+        public bool DeleteReplyMessage { get; set; } = true;
+
+        /// <summary>
+        /// Parsemode of the message.
+        /// </summary>
+        public ParseMode MessageParseMode { get; set; } = ParseMode.Default;
+
+        /// <summary>
+        /// Enables automatic paging of buttons when the amount of rows is exceeding the limits.
+        /// </summary>
+        public bool EnablePaging { get; set; } = false;
+
+
+        ///// <summary>
+        ///// Enabled a search function.
+        ///// </summary>
+        //public bool EnableSearch { get; set; } = false;
+
+        //public String SearchQuery { get; set; }
+
+        public eNavigationBarVisibility NavigationBarVisibility { get; set; } = eNavigationBarVisibility.always;
+
+
+        /// <summary>
+        /// Index of the current page
+        /// </summary>
+        public int CurrentPageIndex { get; set; } = 0;
+
+        public String PreviousPageLabel = Localizations.Default.Language["ButtonGrid_PreviousPage"];
+
+        public String NextPageLabel = Localizations.Default.Language["ButtonGrid_NextPage"];
+
+        public String NoItemsLabel = Localizations.Default.Language["ButtonGrid_NoItems"];
+
+        //public String SearchLabel = Localizations.Default.Language["ButtonGrid_SearchFeature"];
+
+        public String CheckedIconLabel { get; set; } = "✅";
+
+        public String UncheckedIconLabel { get; set; } = "◻️";
+
+        /// <summary>
+        /// Layout of the buttons which should be displayed always on top.
+        /// </summary>
+        public ButtonRow HeadLayoutButtonRow { get; set; }
+
+        /// <summary>
+        /// Layout of columns which should be displayed below the header
+        /// </summary>
+        public ButtonRow SubHeadLayoutButtonRow { get; set; }
+
+        /// <summary>
+        /// Defines which type of Button Keyboard should be rendered.
+        /// </summary>
+        public eKeyboardType KeyboardType
+        {
+            get
+            {
+                return m_eKeyboardType;
+            }
+            set
+            {
+                if (m_eKeyboardType != value)
+                {
+                    this.RenderNecessary = true;
+
+                    Cleanup().Wait();
+
+                    m_eKeyboardType = value;
+                }
+
+            }
+        }
+
+        private eKeyboardType m_eKeyboardType = eKeyboardType.ReplyKeyboard;
+
+        public CheckedButtonList()
+        {
+            this.DataSource = new ButtonFormDataSource();
+
+
+        }
+
+        public CheckedButtonList(eKeyboardType type) : this()
+        {
+            m_eKeyboardType = type;
+        }
+
+
+        public CheckedButtonList(ButtonForm form)
+        {
+            this.DataSource = new ButtonFormDataSource(form);
+        }
+
+        public event AsyncEventHandler<ButtonClickedEventArgs> ButtonClicked
+        {
+            add
+            {
+                this.Events.AddHandler(__evButtonClicked, value);
+            }
+            remove
+            {
+                this.Events.RemoveHandler(__evButtonClicked, value);
+            }
+        }
+
+        public async Task OnButtonClicked(ButtonClickedEventArgs e)
+        {
+            var handler = this.Events[__evButtonClicked]?.GetInvocationList().Cast<AsyncEventHandler<ButtonClickedEventArgs>>();
+            if (handler == null)
+                return;
+
+            foreach (var h in handler)
+            {
+                await Async.InvokeAllAsync<ButtonClickedEventArgs>(h, this, e);
+            }
+        }
+
+        public event AsyncEventHandler<CheckedChangedEventArgs> CheckedChanged
+        {
+            add
+            {
+                this.Events.AddHandler(__evCheckedChanged, value);
+            }
+            remove
+            {
+                this.Events.RemoveHandler(__evCheckedChanged, value);
+            }
+        }
+
+        public async Task OnCheckedChanged(CheckedChangedEventArgs e)
+        {
+            var handler = this.Events[__evCheckedChanged]?.GetInvocationList().Cast<AsyncEventHandler<CheckedChangedEventArgs>>();
+            if (handler == null)
+                return;
+
+            foreach (var h in handler)
+            {
+                await Async.InvokeAllAsync<CheckedChangedEventArgs>(h, this, e);
+            }
+        }
+
+        public async override Task Load(MessageResult result)
+        {
+            if (this.KeyboardType != eKeyboardType.ReplyKeyboard)
+                return;
+
+            if (!result.IsFirstHandler)
+                return;
+
+            if (result.MessageText == null || result.MessageText == "")
+                return;
+
+            var matches = new List<ButtonRow>();
+            ButtonRow match = null;
+            int index = -1;
+
+            if (HeadLayoutButtonRow?.Matches(result.MessageText) ?? false)
+            {
+                match = HeadLayoutButtonRow;
+                goto check;
+            }
+
+            if (SubHeadLayoutButtonRow?.Matches(result.MessageText) ?? false)
+            {
+                match = SubHeadLayoutButtonRow;
+                goto check;
+            }
+
+            var br = DataSource.FindRow(result.MessageText);
+            if (br != null)
+            {
+                match = br.Item1;
+                index = br.Item2;
+            }
+
+
+        //var button = HeadLayoutButtonRow?. .FirstOrDefault(a => a.Text.Trim() == result.MessageText)
+        //            ?? SubHeadLayoutButtonRow?.FirstOrDefault(a => a.Text.Trim() == result.MessageText);
+
+        // bf.ToList().FirstOrDefault(a => a.Text.Trim() == result.MessageText)
+
+        //var index = bf.FindRowByButton(button);
+
+
+
+        check:
+
+
+            //Remove button click message
+            if (this.DeleteReplyMessage)
+                await Device.DeleteMessage(result.MessageId);
+
+            if (match == null)
+            {
+                if (result.MessageText == PreviousPageLabel)
+                {
+                    if (this.CurrentPageIndex > 0)
+                        this.CurrentPageIndex--;
+
+                    this.Updated();
+                }
+                else if (result.MessageText == NextPageLabel)
+                {
+                    if (this.CurrentPageIndex < this.PageCount - 1)
+                        this.CurrentPageIndex++;
+
+                    this.Updated();
+                }
+                else if (result.MessageText.EndsWith(CheckedIconLabel))
+                {
+                    var s = result.MessageText.Split(' ', '.');
+                    index = int.Parse(s[0]) - 1;
+
+                    if (!this.CheckedRows.Contains(index))
+                        return;
+
+                    this.CheckedRows.Remove(index);
+
+                    this.Updated();
+
+                    await OnCheckedChanged(new CheckedChangedEventArgs(ButtonsForm[index], index, false));
+
+                }
+                else if (result.MessageText.EndsWith(UncheckedIconLabel))
+                {
+                    var s = result.MessageText.Split(' ', '.');
+                    index = int.Parse(s[0]) - 1;
+
+                    if (this.CheckedRows.Contains(index))
+                        return;
+
+
+                    this.CheckedRows.Add(index);
+
+                    this.Updated();
+
+                    await OnCheckedChanged(new CheckedChangedEventArgs(ButtonsForm[index], index, true));
+
+                }
+                //else if (this.EnableSearch)
+                //{
+                //    if (result.MessageText.StartsWith("🔍"))
+                //    {
+                //        //Sent note about searching
+                //        if (this.SearchQuery == null)
+                //        {
+                //            await this.Device.Send(this.SearchLabel);
+                //        }
+
+                //        this.SearchQuery = null;
+                //        this.Updated();
+                //        return;
+                //    }
+
+                //    this.SearchQuery = result.MessageText;
+
+                //    if (this.SearchQuery != null && this.SearchQuery != "")
+                //    {
+                //        this.CurrentPageIndex = 0;
+                //        this.Updated();
+                //    }
+
+                //}
+
+
+
+                return;
+            }
+
+
+            await OnButtonClicked(new ButtonClickedEventArgs(match.GetButtonMatch(result.MessageText), index, match));
+
+            result.Handled = true;
+
+            //await OnButtonClicked(new ButtonClickedEventArgs(button, index));
+
+            ////Remove button click message
+            //if (this.DeletePreviousMessage)
+            //    await Device.DeleteMessage(result.MessageId);
+
+            //result.Handled = true;
+
+        }
+
+        public async override Task Action(MessageResult result, string value = null)
+        {
+            if (result.Handled)
+                return;
+
+            if (!result.IsFirstHandler)
+                return;
+
+            //Find clicked button depending on Text or Value (depending on markup type)
+            if (this.KeyboardType != eKeyboardType.InlineKeyBoard)
+                return;
+
+            await result.ConfirmAction(this.ConfirmationText ?? "");
+
+            ButtonRow match = null;
+            int index = -1;
+
+            if (HeadLayoutButtonRow?.Matches(result.RawData, false) ?? false)
+            {
+                match = HeadLayoutButtonRow;
+                goto check;
+            }
+
+            if (SubHeadLayoutButtonRow?.Matches(result.RawData, false) ?? false)
+            {
+                match = SubHeadLayoutButtonRow;
+                goto check;
+            }
+
+            var br = DataSource.FindRow(result.RawData, false);
+            if (br != null)
+            {
+                match = br.Item1;
+                index = br.Item2;
+            }
+
+
+
+        //var bf = DataSource.ButtonForm;
+
+        //var button = HeadLayoutButtonRow?.FirstOrDefault(a => a.Value == result.RawData)
+        //            ?? SubHeadLayoutButtonRow?.FirstOrDefault(a => a.Value == result.RawData)
+        //            ?? bf.ToList().FirstOrDefault(a => a.Value == result.RawData);
+
+        //var index = bf.FindRowByButton(button);
+
+        check:
+            if (match != null)
+            {
+                await OnButtonClicked(new ButtonClickedEventArgs(match.GetButtonMatch(result.RawData, false), index, match));
+
+                result.Handled = true;
+                return;
+            }
+
+            //if (button != null)
+            //{
+            //    await OnButtonClicked(new ButtonClickedEventArgs(button, index));
+
+            //    result.Handled = true;
+            //    return;
+            //}
+
+            switch (result.RawData)
+            {
+                case "$previous$":
+
+                    if (this.CurrentPageIndex > 0)
+                        this.CurrentPageIndex--;
+
+                    this.Updated();
+
+                    break;
+                case "$next$":
+
+                    if (this.CurrentPageIndex < this.PageCount - 1)
+                        this.CurrentPageIndex++;
+
+                    this.Updated();
+
+                    break;
+
+                default:
+
+                    var s = result.RawData.Split('$');
+
+
+                    switch (s[0])
+                    {
+                        case "check":
+
+                            index = int.Parse(s[1]);
+
+                            if (!this.CheckedRows.Contains(index))
+                            {
+                                this.CheckedRows.Add(index);
+
+                                this.Updated();
+
+                                await OnCheckedChanged(new CheckedChangedEventArgs(ButtonsForm[index], index, true));
+                            }
+
+                            break;
+
+                        case "uncheck":
+
+                            index = int.Parse(s[1]);
+
+                            if (this.CheckedRows.Contains(index))
+                            {
+                                this.CheckedRows.Remove(index);
+
+                                this.Updated();
+
+                                await OnCheckedChanged(new CheckedChangedEventArgs(ButtonsForm[index], index, false));
+                            }
+
+                            break;
+                    }
+
+
+                    break;
+
+            }
+
+        }
+
+        /// <summary>
+        /// This method checks of the amount of buttons
+        /// </summary>
+        private void CheckGrid()
+        {
+            switch (m_eKeyboardType)
+            {
+                case eKeyboardType.InlineKeyBoard:
+
+                    if (DataSource.RowCount > Constants.Telegram.MaxInlineKeyBoardRows && !this.EnablePaging)
+                    {
+                        throw new MaximumRowsReachedException() { Value = DataSource.RowCount, Maximum = Constants.Telegram.MaxInlineKeyBoardRows };
+                    }
+
+                    if (DataSource.ColumnCount > Constants.Telegram.MaxInlineKeyBoardCols)
+                    {
+                        throw new MaximumColsException() { Value = DataSource.ColumnCount, Maximum = Constants.Telegram.MaxInlineKeyBoardCols };
+                    }
+
+                    break;
+
+                case eKeyboardType.ReplyKeyboard:
+
+                    if (DataSource.RowCount > Constants.Telegram.MaxReplyKeyboardRows && !this.EnablePaging)
+                    {
+                        throw new MaximumRowsReachedException() { Value = DataSource.RowCount, Maximum = Constants.Telegram.MaxReplyKeyboardRows };
+                    }
+
+                    if (DataSource.ColumnCount > Constants.Telegram.MaxReplyKeyboardCols)
+                    {
+                        throw new MaximumColsException() { Value = DataSource.ColumnCount, Maximum = Constants.Telegram.MaxReplyKeyboardCols };
+                    }
+
+                    break;
+            }
+        }
+
+        public async override Task Render(MessageResult result)
+        {
+            if (!this.RenderNecessary)
+                return;
+
+            //Check for rows and column limits
+            CheckGrid();
+
+            this.RenderNecessary = false;
+
+            Message m = null;
+
+            ButtonForm form = this.DataSource.PickItems(CurrentPageIndex * ItemRowsPerPage, ItemRowsPerPage, null);
+
+            //if (this.EnableSearch && this.SearchQuery != null && this.SearchQuery != "")
+            //{
+            //    form = form.FilterDuplicate(this.SearchQuery, true);
+            //}
+            //else
+            //{
+            //form = form.Duplicate();
+            //}
+
+            if (this.EnablePaging)
+            {
+                IntegratePagingView(form);
+            }
+            else
+            {
+                form = PrepareCheckableLayout(form);
+            }
+
+            if (this.HeadLayoutButtonRow != null && HeadLayoutButtonRow.Count > 0)
+            {
+                form.InsertButtonRow(0, this.HeadLayoutButtonRow.ToArray());
+            }
+
+            if (this.SubHeadLayoutButtonRow != null && SubHeadLayoutButtonRow.Count > 0)
+            {
+                if (this.IsNavigationBarVisible)
+                {
+                    form.InsertButtonRow(2, this.SubHeadLayoutButtonRow.ToArray());
+                }
+                else
+                {
+                    form.InsertButtonRow(1, this.SubHeadLayoutButtonRow.ToArray());
+                }
+            }
+
+            switch (this.KeyboardType)
+            {
+                //Reply Keyboard could only be updated with a new keyboard.
+                case eKeyboardType.ReplyKeyboard:
+
+                    if (form.Count == 0)
+                    {
+                        if (this.MessageId != null)
+                        {
+                            await this.Device.HideReplyKeyboard();
+                            this.MessageId = null;
+                        }
+
+                        return;
+                    }
+
+                    //if (form.Count == 0)
+                    //    return;
+
+
+                    var rkm = (ReplyKeyboardMarkup)form;
+                    rkm.ResizeKeyboard = this.ResizeKeyboard;
+                    rkm.OneTimeKeyboard = this.OneTimeKeyboard;
+                    m = await this.Device.Send(this.Title, rkm, disableNotification: true, parseMode: MessageParseMode, MarkdownV2AutoEscape: false);
+
+                    //Prevent flicker of keyboard
+                    if (this.DeletePreviousMessage && this.MessageId != null)
+                        await this.Device.DeleteMessage(this.MessageId.Value);
+
+                    break;
+
+                case eKeyboardType.InlineKeyBoard:
+
+                    if (this.MessageId != null)
+                    {
+                        m = await this.Device.Edit(this.MessageId.Value, this.Title, (InlineKeyboardMarkup)form);
+                    }
+                    else
+                    {
+                        m = await this.Device.Send(this.Title, (InlineKeyboardMarkup)form, disableNotification: true, parseMode: MessageParseMode, MarkdownV2AutoEscape: false);
+                    }
+
+                    break;
+            }
+
+            if (m != null)
+            {
+                this.MessageId = m.MessageId;
+            }
+
+
+        }
+
+        private void IntegratePagingView(ButtonForm dataForm)
+        {
+            //No Items 
+            if (dataForm.Rows == 0)
+            {
+                dataForm.AddButtonRow(new ButtonBase(NoItemsLabel, "$"));
+            }
+
+            ButtonForm bf = new ButtonForm();
+
+            bf = PrepareCheckableLayout(dataForm);
+
+
+            if (this.IsNavigationBarVisible)
+            {
+                //🔍
+                ButtonRow row = new ButtonRow();
+                row.Add(new ButtonBase(PreviousPageLabel, "$previous$"));
+                row.Add(new ButtonBase(String.Format(Localizations.Default.Language["ButtonGrid_CurrentPage"], this.CurrentPageIndex + 1, this.PageCount), "$site$"));
+                row.Add(new ButtonBase(NextPageLabel, "$next$"));
+
+
+                dataForm.InsertButtonRow(0, row);
+
+                dataForm.AddButtonRow(row);
+            }
+        }
+
+        private ButtonForm PrepareCheckableLayout(ButtonForm dataForm)
+        {
+            var bf = new ButtonForm();
+            for (int i = 0; i < dataForm.Rows; i++)
+            {
+                int it = (this.CurrentPageIndex * (this.MaximumRow - LayoutRows)) + i;
+
+                //if (it > dataForm.Rows - 1)
+                //    break;
+
+                var r = dataForm[i];
+
+                String s = CheckedRows.Contains(it) ? this.CheckedIconLabel : this.UncheckedIconLabel;
+
+                //On reply keyboards we need a unique text.
+                if (this.KeyboardType == eKeyboardType.ReplyKeyboard)
+                {
+                    s = $"{it + 1}. " + s;
+                }
+
+                if (CheckedRows.Contains(it))
+                {
+                    r.Insert(0, new ButtonBase(s, "uncheck$" + it.ToString()));
+                }
+                else
+                {
+                    r.Insert(0, new ButtonBase(s, "check$" + it.ToString()));
+                }
+
+                bf.AddButtonRow(r);
+            }
+
+            return bf;
+        }
+
+        public bool PagingNecessary
+        {
+            get
+            {
+                if (this.KeyboardType == eKeyboardType.InlineKeyBoard && TotalRows > Constants.Telegram.MaxInlineKeyBoardRows)
+                {
+                    return true;
+                }
+
+                if (this.KeyboardType == eKeyboardType.ReplyKeyboard && TotalRows > Constants.Telegram.MaxReplyKeyboardRows)
+                {
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        public bool IsNavigationBarVisible
+        {
+            get
+            {
+                if (this.NavigationBarVisibility == eNavigationBarVisibility.always | (this.NavigationBarVisibility == eNavigationBarVisibility.auto && PagingNecessary))
+                {
+                    return true;
+                }
+
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Returns the maximum number of rows
+        /// </summary>
+        public int MaximumRow
+        {
+            get
+            {
+                switch (this.KeyboardType)
+                {
+                    case eKeyboardType.InlineKeyBoard:
+                        return Constants.Telegram.MaxInlineKeyBoardRows;
+
+                    case eKeyboardType.ReplyKeyboard:
+                        return Constants.Telegram.MaxReplyKeyboardRows;
+
+                    default:
+                        return 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns the number of all rows (layout + navigation + content);
+        /// </summary>
+        public int TotalRows
+        {
+            get
+            {
+                return this.LayoutRows + DataSource.RowCount;
+            }
+        }
+
+
+        /// <summary>
+        /// Contains the Number of Rows which are used by the layout.
+        /// </summary>
+        private int LayoutRows
+        {
+            get
+            {
+                int layoutRows = 0;
+
+                if (this.NavigationBarVisibility == eNavigationBarVisibility.always | this.NavigationBarVisibility == eNavigationBarVisibility.auto)
+                    layoutRows += 2;
+
+                if (this.HeadLayoutButtonRow != null && this.HeadLayoutButtonRow.Count > 0)
+                    layoutRows++;
+
+                if (this.SubHeadLayoutButtonRow != null && this.SubHeadLayoutButtonRow.Count > 0)
+                    layoutRows++;
+
+                return layoutRows;
+            }
+        }
+
+        /// <summary>
+        /// Returns the number of item rows per page.
+        /// </summary>
+        public int ItemRowsPerPage
+        {
+            get
+            {
+                return this.MaximumRow - this.LayoutRows;
+            }
+        }
+
+        public int PageCount
+        {
+            get
+            {
+                if (DataSource.RowCount == 0)
+                    return 1;
+
+                //var bf = this.DataSource.PickAllItems(this.EnableSearch ? this.SearchQuery : null);
+
+                var max = this.DataSource.RowCount;
+
+                //if (this.EnableSearch && this.SearchQuery != null && this.SearchQuery != "")
+                //{
+                //    bf = bf.FilterDuplicate(this.SearchQuery);
+                //}
+
+                if (max == 0)
+                    return 1;
+
+                return (int)Math.Ceiling((decimal)((decimal)max / (decimal)ItemRowsPerPage));
+            }
+        }
+
+        public override async Task Hidden(bool FormClose)
+        {
+            //Prepare for opening Modal, and comming back
+            if (!FormClose)
+            {
+                this.Updated();
+            }
+        }
+
+        public List<ButtonBase> CheckedItems
+        {
+            get
+            {
+                List<ButtonBase> lst = new List<ButtonBase>();
+
+                foreach (var c in CheckedRows)
+                {
+                    lst.Add(this.ButtonsForm[c][0]);
+                }
+
+                return lst;
+            }
+        }
+
+
+        /// <summary>
+        /// Tells the control that it has been updated.
+        /// </summary>
+        public void Updated()
+        {
+            this.RenderNecessary = true;
+        }
+
+        public async override Task Cleanup()
+        {
+            if (this.MessageId == null)
+                return;
+
+            switch (this.KeyboardType)
+            {
+                case eKeyboardType.InlineKeyBoard:
+
+                    await this.Device.DeleteMessage(this.MessageId.Value);
+
+                    this.MessageId = null;
+
+                    break;
+                case eKeyboardType.ReplyKeyboard:
+
+                    if (this.HideKeyboardOnCleanup)
+                    {
+                        await this.Device.HideReplyKeyboard();
+                    }
+
+                    this.MessageId = null;
+
+                    break;
+            }
+
+
+
+
+        }
+
+    }
+
+
+}

TelegramBotBase/Controls/Hybrid/MultiView.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Args;
+using TelegramBotBase.Base;
+
+namespace TelegramBotBase.Controls.Hybrid
+{
+
+    /// <summary>
+    /// This Control is for having a basic form content switching control.
+    /// </summary>
+    public abstract class MultiView : Base.ControlBase
+    {
+        /// <summary>
+        /// Index of the current View.
+        /// </summary>
+        public int SelectedViewIndex
+        {
+            get
+            {
+                return m_iSelectedViewIndex;
+            }
+            set
+            {
+                m_iSelectedViewIndex = value;
+
+                //Already rendered? Re-Render
+                if (_Rendered)
+                    ForceRender().Wait();
+            }
+        }
+
+        private int m_iSelectedViewIndex = 0;
+
+        /// <summary>
+        /// Hold if the View has been rendered already.
+        /// </summary>
+        private bool _Rendered = false;
+
+        private List<int> Messages { get; set; }
+
+
+        public MultiView()
+        {
+            Messages = new List<int>();
+        }
+
+
+        private void Device_MessageSent(object sender, MessageSentEventArgs e)
+        {
+            if (e.Origin == null || !e.Origin.IsSubclassOf(typeof(MultiView)))
+                return;
+
+            this.Messages.Add(e.MessageId);
+        }
+
+        public override void Init()
+        {
+            Device.MessageSent += Device_MessageSent;
+        }
+
+        public override async Task Load(MessageResult result)
+        {
+            _Rendered = false;
+        }
+
+
+        public override async Task Render(MessageResult result)
+        {
+            //When already rendered, skip rendering
+            if (_Rendered)
+                return;
+
+            await CleanUpView();
+
+            await RenderView(new RenderViewEventArgs(this.SelectedViewIndex));
+
+            _Rendered = true;
+        }
+
+
+        /// <summary>
+        /// Will get invoked on rendering the current controls view.
+        /// </summary>
+        /// <param name="e"></param>
+        public virtual async Task RenderView(RenderViewEventArgs e)
+        {
+
+
+        }
+
+        async Task CleanUpView()
+        {
+
+            var tasks = new List<Task>();
+
+            foreach (var msg in this.Messages)
+            {
+                tasks.Add(this.Device.DeleteMessage(msg));
+            }
+
+            await Task.WhenAll(tasks);
+
+            this.Messages.Clear();
+
+        }
+
+        /// <summary>
+        /// Forces render of control contents.
+        /// </summary>
+        public async Task ForceRender()
+        {
+            await CleanUpView();
+
+            await RenderView(new RenderViewEventArgs(this.SelectedViewIndex));
+
+            _Rendered = true;
+        }
+
+        public override async Task Cleanup()
+        {
+            Device.MessageSent -= Device_MessageSent;
+
+            await CleanUpView();
+        }
+
+    }
+}

TelegramBotBase/Controls/Inline/CalendarPicker.cs

@@ -7,11 +7,11 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Enums;
 using TelegramBotBase.Form;
-
+using TelegramBotBase.Tools;
 using static TelegramBotBase.Tools.Arrays;
 using static TelegramBotBase.Tools.Time;
 
-namespace TelegramBotBase.Controls
+namespace TelegramBotBase.Controls.Inline
 {
     public class CalendarPicker : Base.ControlBase
     {
@@ -27,7 +27,7 @@ namespace TelegramBotBase.Controls
 
         private int? MessageId { get; set; }
 
-        public String Title { get; set; } = "Pick Date";
+        public String Title { get; set; } = Localizations.Default.Language["CalendarPicker_Title"];
 
         public eMonthPickerMode PickerMode { get; set; }
 
@@ -36,15 +36,17 @@ namespace TelegramBotBase.Controls
         public bool EnableMonthView { get; set; } = true;
 
         public bool EnableYearView { get; set; } = true;
-
+        
-        public CalendarPicker()
+        public CalendarPicker(CultureInfo culture)
         {
             this.SelectedDate = DateTime.Today;
             this.VisibleMonth = DateTime.Today;
             this.FirstDayOfWeek = DayOfWeek.Monday;
-            this.Culture = new CultureInfo("de-de");
+            this.Culture = culture;
             this.PickerMode = eMonthPickerMode.day;
         }
+        
+        public CalendarPicker() : this(new CultureInfo("en-en")) { }
 
 
 
@@ -55,7 +57,7 @@ namespace TelegramBotBase.Controls
 
             switch (result.RawData)
             {
-                case "next":
+                case "$next$":
 
                     switch (this.PickerMode)
                     {
@@ -74,7 +76,7 @@ namespace TelegramBotBase.Controls
 
 
                     break;
-                case "prev":
+                case "$prev$":
 
                     switch (this.PickerMode)
                     {
@@ -93,7 +95,7 @@ namespace TelegramBotBase.Controls
 
                     break;
 
-                case "monthtitle":
+                case "$monthtitle$":
 
                     if (this.EnableMonthView)
                     {
@@ -102,7 +104,7 @@ namespace TelegramBotBase.Controls
 
                     break;
 
-                case "yeartitle":
+                case "$yeartitle$":
 
                     if (this.EnableYearView)
                     {
@@ -110,7 +112,7 @@ namespace TelegramBotBase.Controls
                     }
 
                     break;
-                case "yearstitle":
+                case "$yearstitle$":
 
                     if (this.EnableMonthView)
                     {
@@ -124,13 +126,13 @@ namespace TelegramBotBase.Controls
                 default:
 
                     int day = 0;
-                    if (result.RawData.StartsWith("d-") && int.TryParse(result.RawData.Split('-')[1], out day))
+                    if (result.RawData.StartsWith("d-") && TryParseDay(result.RawData.Split('-')[1], this.SelectedDate, out day))
                     {
                         this.SelectedDate = new DateTime(this.VisibleMonth.Year, this.VisibleMonth.Month, day);
                     }
 
                     int month = 0;
-                    if (result.RawData.StartsWith("m-") && int.TryParse(result.RawData.Split('-')[1], out month))
+                    if (result.RawData.StartsWith("m-") && TryParseMonth(result.RawData.Split('-')[1], out month))
                     {
                         this.SelectedDate = new DateTime(this.VisibleMonth.Year, month, 1);
                         this.VisibleMonth = this.SelectedDate;
@@ -142,7 +144,7 @@ namespace TelegramBotBase.Controls
                     }
 
                     int year = 0;
-                    if (result.RawData.StartsWith("y-") && int.TryParse(result.RawData.Split('-')[1], out year))
+                    if (result.RawData.StartsWith("y-") && TryParseYear(result.RawData.Split('-')[1], out year))
                     {
                         this.SelectedDate = new DateTime(year, SelectedDate.Month, SelectedDate.Day);
                         this.VisibleMonth = this.SelectedDate;
@@ -179,7 +181,7 @@ namespace TelegramBotBase.Controls
                     string[] dayNamesNormal = this.Culture.DateTimeFormat.ShortestDayNames;
                     string[] dayNamesShifted = Shift(dayNamesNormal, (int)this.FirstDayOfWeek);
 
-                    bf.AddButtonRow(new ButtonBase("<<", "prev"), new ButtonBase(this.Culture.DateTimeFormat.MonthNames[month.Month - 1] + " " + month.Year.ToString(), "monthtitle"), new ButtonBase(">>", "next"));
+                    bf.AddButtonRow(new ButtonBase(Localizations.Default.Language["CalendarPicker_PreviousPage"], "$prev$"), new ButtonBase(this.Culture.DateTimeFormat.MonthNames[month.Month - 1] + " " + month.Year.ToString(), "$monthtitle$"), new ButtonBase(Localizations.Default.Language["CalendarPicker_NextPage"], "$next$"));
 
                     bf.AddButtonRow(dayNamesShifted.Select(a => new ButtonBase(a, a)).ToList());
 
@@ -223,7 +225,7 @@ namespace TelegramBotBase.Controls
 
                 case eMonthPickerMode.month:
 
-                    bf.AddButtonRow(new ButtonBase("<<", "prev"), new ButtonBase(this.VisibleMonth.Year.ToString("0000"), "yeartitle"), new ButtonBase(">>", "next"));
+                    bf.AddButtonRow(new ButtonBase(Localizations.Default.Language["CalendarPicker_PreviousPage"], "$prev$"), new ButtonBase(this.VisibleMonth.Year.ToString("0000"), "$yeartitle$"), new ButtonBase(Localizations.Default.Language["CalendarPicker_NextPage"], "$next$"));
 
                     var months = this.Culture.DateTimeFormat.MonthNames;
 
@@ -235,7 +237,7 @@ namespace TelegramBotBase.Controls
 
                 case eMonthPickerMode.year:
 
-                    bf.AddButtonRow(new ButtonBase("<<", "prev"), new ButtonBase("Year", "yearstitle"), new ButtonBase(">>", "next"));
+                    bf.AddButtonRow(new ButtonBase(Localizations.Default.Language["CalendarPicker_PreviousPage"], "$prev$"), new ButtonBase("Year", "$yearstitle$"), new ButtonBase(Localizations.Default.Language["CalendarPicker_NextPage"], "$next$"));
 
                     var starti = Math.Floor(this.VisibleMonth.Year / 10f) * 10;
 

TelegramBotBase/Controls/Inline/MonthPicker.cs

@@ -8,7 +8,7 @@ using TelegramBotBase.Base;
 using TelegramBotBase.Enums;
 using TelegramBotBase.Form;
 
-namespace TelegramBotBase.Controls
+namespace TelegramBotBase.Controls.Inline
 {
     public class MonthPicker : CalendarPicker
     {

TelegramBotBase/Controls/Inline/MultiToggleButton.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Controls.Inline
+{
+    public class MultiToggleButton : ControlBase
+    {
+        /// <summary>
+        /// This contains the selected icon.
+        /// </summary>
+        public String SelectedIcon { get; set; } = Localizations.Default.Language["MultiToggleButton_SelectedIcon"];
+
+        /// <summary>
+        /// This will appear on the ConfirmAction message (if not empty)
+        /// </summary>
+        public String ChangedString { get; set; } = Localizations.Default.Language["MultiToggleButton_Changed"];
+
+        /// <summary>
+        /// This holds the title of the control.
+        /// </summary>
+        public String Title { get; set; } = Localizations.Default.Language["MultiToggleButton_Title"];
+
+        public int? MessageId { get; set; }
+
+        private bool RenderNecessary = true;
+
+        private static readonly object __evToggled = new object();
+
+        private readonly EventHandlerList Events = new EventHandlerList();
+
+        /// <summary>
+        /// This will hold all options available.
+        /// </summary>
+        public List<ButtonBase> Options { get; set; }
+
+        /// <summary>
+        /// This will set if an empty selection (null) is allowed.
+        /// </summary>
+        public bool AllowEmptySelection { get; set; } = true;
+
+
+        public MultiToggleButton()
+        {
+            Options = new List<ButtonBase>();
+        }
+
+        public event EventHandler Toggled
+        {
+            add
+            {
+                this.Events.AddHandler(__evToggled, value);
+            }
+            remove
+            {
+                this.Events.RemoveHandler(__evToggled, value);
+            }
+        }
+
+        public void OnToggled(EventArgs e)
+        {
+            (this.Events[__evToggled] as EventHandler)?.Invoke(this, e);
+        }
+
+        public override async Task Action(MessageResult result, String value = null)
+        {
+            if (result.Handled)
+                return;
+
+            await result.ConfirmAction(this.ChangedString);
+
+            switch (value ?? "unknown")
+            {
+                default:
+
+                    var s = value.Split('$');
+
+                    if (s[0] == "check" && s.Length > 1)
+                    {
+                        int index = 0;
+                        if (!int.TryParse(s[1], out index))
+                        {
+                            return;
+                        }
+
+                        if(SelectedOption== null || SelectedOption != this.Options[index])
+                        {
+                            this.SelectedOption = this.Options[index];
+                            OnToggled(new EventArgs());
+                        }
+                        else if(this.AllowEmptySelection)
+                        {
+                            this.SelectedOption = null;
+                            OnToggled(new EventArgs());
+                        }
+
+                        RenderNecessary = true;
+
+                        return;
+                    }
+
+
+                    RenderNecessary = false;
+
+                    break;
+
+            }
+
+            result.Handled = true;
+
+        }
+
+        public override async Task Render(MessageResult result)
+        {
+            if (!RenderNecessary)
+                return;
+
+            var bf = new ButtonForm(this);
+
+            var lst = new List<ButtonBase>();
+            foreach (var o in this.Options)
+            {
+                var index = this.Options.IndexOf(o);
+                if (o == this.SelectedOption)
+                {
+                    lst.Add(new ButtonBase(SelectedIcon + " " + o.Text, "check$" + index));
+                    continue;
+                }
+
+                lst.Add(new ButtonBase(o.Text, "check$" + index));
+            }
+
+            bf.AddButtonRow(lst);
+
+            if (this.MessageId != null)
+            {
+                var m = await this.Device.Edit(this.MessageId.Value, this.Title, bf);
+            }
+            else
+            {
+                var m = await this.Device.Send(this.Title, bf, disableNotification: true);
+                if (m != null)
+                {
+                    this.MessageId = m.MessageId;
+                }
+            }
+
+            this.RenderNecessary = false;
+
+
+        }
+
+        public ButtonBase SelectedOption
+        {
+            get; set;
+        }
+
+    }
+}

TelegramBotBase/Controls/Inline/ProgressBar.cs

@@ -5,7 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Base;
 
-namespace TelegramBotBase.Controls
+namespace TelegramBotBase.Controls.Inline
 {
     /// <summary>
     /// A simple control for show and managing progress.

TelegramBotBase/Controls/Inline/ToggleButton.cs

@@ -7,20 +7,22 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBotBase.Controls
+namespace TelegramBotBase.Controls.Inline
 {
     public class ToggleButton : ControlBase
     {
 
-        public String UncheckedIcon { get; set; } = "⚪";
+        public String UncheckedIcon { get; set; } = Localizations.Default.Language["ToggleButton_OffIcon"];
 
-        public String CheckedIcon { get; set; } = "⚫";
+        public String CheckedIcon { get; set; } = Localizations.Default.Language["ToggleButton_OnIcon"];
 
-        public String CheckedString { get; set; } = "On";
+        public String CheckedString { get; set; } = Localizations.Default.Language["ToggleButton_On"];
 
-        public String UncheckedString { get; set; } = "Off";
+        public String UncheckedString { get; set; } = Localizations.Default.Language["ToggleButton_Off"];
 
-        public String Title { get; set; } = "Toggle";
+        public String ChangedString { get; set; } = Localizations.Default.Language["ToggleButton_Changed"];
+
+        public String Title { get; set; } = Localizations.Default.Language["ToggleButton_Title"];
 
         public int? MessageId { get; set; }
 
@@ -68,7 +70,7 @@ namespace TelegramBotBase.Controls
             if (result.Handled)
                 return;
 
-            await result.ConfirmAction();
+            await result.ConfirmAction(this.ChangedString);
 
             switch (value ?? "unknown")
             {

TelegramBotBase/Controls/Inline/TreeView.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBotBase.Controls
+namespace TelegramBotBase.Controls.Inline
 {
     public class TreeView : ControlBase
     {
@@ -20,12 +20,12 @@ namespace TelegramBotBase.Controls
 
         private int? MessageId { get; set; }
 
-        public String MoveUpIcon { get; set; } = "🔼 up";
+        public String MoveUpIcon { get; set; } = Localizations.Default.Language["TreeView_LevelUp"];
 
         public TreeView()
         {
             this.Nodes = new List<TreeViewNode>();
-            this.Title = "Select node";
+            this.Title = Localizations.Default.Language["TreeView_Title"];
         }
 
 
@@ -52,19 +52,21 @@ namespace TelegramBotBase.Controls
 
                     var n = (this.VisibleNode != null ? this.VisibleNode.FindNodeByValue(val) : this.Nodes.FirstOrDefault(a => a.Value == val));
 
-                    if (n != null)
+                    if (n == null)
-                    {
+                        return;
-                        if (n.ChildNodes.Count > 0)
-                        {
-                            this.VisibleNode = n;
-                        }
-                        else
-                        {
-                            this.SelectedNode = (this.SelectedNode != n ? n : null);
-                        }
 
-                        result.Handled = true;
+
+                    if (n.ChildNodes.Count > 0)
+                    {
+                        this.VisibleNode = n;
                     }
+                    else
+                    {
+                        this.SelectedNode = (this.SelectedNode != n ? n : null);
+                    }
+
+                    result.Handled = true;
+
 
                     break;
 

TelegramBotBase/Controls/Inline/TreeViewNode.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace TelegramBotBase.Controls
+namespace TelegramBotBase.Controls.Inline
 {
     public class TreeViewNode
     {

TelegramBotBase/Datasources/ButtonFormDataSource.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Form;
+using TelegramBotBase.Interfaces;
+
+namespace TelegramBotBase.Datasources
+{
+    public class ButtonFormDataSource : Interfaces.IDataSource<ButtonRow>
+    {
+        public virtual ButtonForm ButtonForm
+        {
+            get
+            {
+                return __buttonform;
+            }
+            set
+            {
+                __buttonform = value;
+            }
+        }
+
+        private ButtonForm __buttonform = null;
+
+        public ButtonFormDataSource()
+        {
+            __buttonform = new ButtonForm();
+        }
+
+        public ButtonFormDataSource(ButtonForm bf)
+        {
+            __buttonform = bf;
+        }
+
+
+        /// <summary>
+        /// Returns the amount of rows exisiting.
+        /// </summary>
+        /// <returns></returns>
+        public virtual int Count => ButtonForm.Count;
+
+
+        /// <summary>
+        /// Returns the amount of rows.
+        /// </summary>
+        public virtual int RowCount => ButtonForm.Rows;
+
+        /// <summary>
+        /// Returns the maximum amount of columns.
+        /// </summary>
+        public virtual int ColumnCount => ButtonForm.Cols;
+
+        /// <summary>
+        /// Returns the row with the specific index.
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public virtual ButtonRow ItemAt(int index)
+        {
+            return ButtonForm[index];
+        }
+
+        public virtual List<ButtonRow> ItemRange(int start, int count)
+        {
+            return ButtonForm.GetRange(start, count);
+        }
+
+        public virtual List<ButtonRow> AllItems()
+        {
+            return ButtonForm.ToArray();
+        }
+
+        public virtual ButtonForm PickItems(int start, int count, String filter = null)
+        {
+            ButtonForm bf = new ButtonForm();
+            ButtonForm dataForm = null;
+
+            if (filter == null)
+            {
+                dataForm = ButtonForm.Duplicate();
+            }
+            else
+            {
+                dataForm = ButtonForm.FilterDuplicate(filter, true);
+            }
+
+            for (int i = 0; i < count; i++)
+            {
+                int it = start + i;
+
+                if (it > dataForm.Rows - 1)
+                    break;
+
+                bf.AddButtonRow(dataForm[it]);
+            }
+
+            return bf;
+        }
+
+        public virtual ButtonForm PickAllItems(String filter = null)
+        {
+            if (filter == null)
+                return ButtonForm.Duplicate();
+
+
+            return ButtonForm.FilterDuplicate(filter, true);
+        }
+
+        public virtual Tuple<ButtonRow, int> FindRow(String text, bool useText = true)
+        {
+            return ButtonForm.FindRow(text, useText);
+        }
+
+        /// <summary>
+        /// Returns the maximum items of this data source.
+        /// </summary>
+        /// <param name="filter"></param>
+        /// <returns></returns>
+        public virtual int CalculateMax(String filter = null)
+        {
+            return PickAllItems(filter).Rows;
+        }
+
+        public virtual ButtonRow Render(object data)
+        {
+            return data as ButtonRow;
+        }
+
+
+        public static implicit operator ButtonFormDataSource(ButtonForm bf)
+        {
+            return new ButtonFormDataSource(bf);
+        }
+
+        public static implicit operator ButtonForm(ButtonFormDataSource ds)
+        {
+            return ds.ButtonForm;
+        }
+
+    }
+}

TelegramBotBase/Datasources/StaticDataSource.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TelegramBotBase.Datasources
+{
+    public class StaticDataSource<T> : Interfaces.IDataSource<T>
+    {
+        List<T> Data { get; set; }
+
+        public StaticDataSource()
+        {
+
+        }
+
+        public StaticDataSource(List<T> data)
+        {
+            this.Data = data;
+        }
+
+
+        public int Count
+        {
+            get
+            {
+                return Data.Count;
+            }
+        }
+
+        public T ItemAt(int index)
+        {
+            return Data[index];
+        }
+
+        public List<T> ItemRange(int start, int count)
+        {
+            return Data.Skip(start).Take(count).ToList();
+        }
+
+        public List<T> AllItems()
+        {
+            return Data;
+        }
+    }
+}

TelegramBotBase/Enums/eNavigationBarVisibility.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Enums
+{
+    public enum eNavigationBarVisibility
+    {
+        /// <summary>
+        /// Shows it depending on the amount of items.
+        /// </summary>
+        auto = 0,
+
+        /// <summary>
+        /// Will not show it at any time.
+        /// </summary>
+        never = 1,
+
+        /// <summary>
+        /// Will show it at any time.
+        /// </summary>
+        always = 2
+
+    }
+}

TelegramBotBase/Enums/eSettings.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Enums
+{
+    public enum eSettings
+    {
+        /// <summary>
+        /// How often could a form navigate to another (within one user action/call/message)
+        /// </summary>
+        NavigationMaximum = 1,
+
+
+        /// <summary>
+        /// Loggs all messages and sent them to the event handler
+        /// </summary>
+        LogAllMessages = 2,
+
+
+        /// <summary>
+        /// Skips all messages during running (good for big delay updates)
+        /// </summary>
+        SkipAllMessages = 3,
+
+
+        /// <summary>
+        /// Does stick to the console event handler and saves all sessions on exit.
+        /// </summary>
+        SaveSessionsOnConsoleExit = 4,
+
+
+        /// <summary>
+        /// Indicates the maximum number of times a request that received error 
+        /// 429 will be sent again after a timeout until it receives code 200 or an error code not equal to 429.
+        /// </summary>
+        MaxNumberOfRetries = 5,
+
+    }
+}

TelegramBotBase/Form/AlertDialog.cs

@@ -4,6 +4,7 @@ using System.ComponentModel;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using TelegramBotBase.Attributes;
 using TelegramBotBase.Base;
 
 namespace TelegramBotBase.Form
@@ -11,6 +12,7 @@ namespace TelegramBotBase.Form
     /// <summary>
     /// A simple prompt dialog with one ok Button
     /// </summary>
+    [IgnoreState]
     public class AlertDialog : ConfirmDialog
     {
         public String ButtonText { get; set; }

TelegramBotBase/Form/ArrayPromptDialog.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Args;
+using TelegramBotBase.Attributes;
 using TelegramBotBase.Base;
 
 namespace TelegramBotBase.Form
@@ -12,10 +13,18 @@ namespace TelegramBotBase.Form
     /// <summary>
     /// A prompt with a lot of buttons
     /// </summary>
+    [IgnoreState]
     public class ArrayPromptDialog : FormBase
     {
+        /// <summary>
+        /// The message the users sees.
+        /// </summary>
         public String Message { get; set; }
 
+        /// <summary>
+        /// An additional optional value.
+        /// </summary>
+        public object Tag { get; set; }
 
         public ButtonBase[][] Buttons { get; set; }
 
@@ -69,7 +78,7 @@ namespace TelegramBotBase.Form
                 return;
             }
 
-            OnButtonClicked(new ButtonClickedEventArgs(button));
+            OnButtonClicked(new ButtonClickedEventArgs(button) { Tag = this.Tag });
 
             FormBase fb = ButtonForms.ContainsKey(call.Value) ? ButtonForms[call.Value] : null;
 

TelegramBotBase/Form/AutoCleanForm.cs

@@ -1,10 +1,13 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
+using Telegram.Bot.Exceptions;
 using Telegram.Bot.Types;
 using TelegramBotBase.Args;
+using TelegramBotBase.Attributes;
 using TelegramBotBase.Base;
 using TelegramBotBase.Enums;
 
@@ -15,27 +18,29 @@ namespace TelegramBotBase.Form
     /// </summary>
     public class AutoCleanForm : FormBase
     {
-        List<Message> OldMessages { get; set; }
+        [SaveState]
+        public List<int> OldMessages { get; set; }
 
+        [SaveState]
         public eDeleteMode DeleteMode { get; set; }
 
+        [SaveState]
         public eDeleteSide DeleteSide { get; set; }
 
-        
+
 
         public AutoCleanForm()
         {
-            this.OldMessages = new List<Message>();
+            this.OldMessages = new List<int>();
             this.DeleteMode = eDeleteMode.OnEveryCall;
             this.DeleteSide = eDeleteSide.BotOnly;
 
-            this.Init +=  AutoCleanForm_Init;
+            this.Init += AutoCleanForm_Init;
 
             this.Closed += AutoCleanForm_Closed;
 
         }
 
-
         private async Task AutoCleanForm_Init(object sender, InitEventArgs e)
         {
             if (this.Device == null)
@@ -52,7 +57,7 @@ namespace TelegramBotBase.Form
             if (this.DeleteSide == eDeleteSide.BotOnly)
                 return;
 
-            this.OldMessages.Add(e.Message);
+            this.OldMessages.Add(e.Message.MessageId);
         }
 
         private void Device_MessageSent(object sender, MessageSentEventArgs e)
@@ -60,7 +65,7 @@ namespace TelegramBotBase.Form
             if (this.DeleteSide == eDeleteSide.UserOnly)
                 return;
 
-            this.OldMessages.Add(e.Message);
+            this.OldMessages.Add(e.Message.MessageId);
         }
 
         public override async Task PreLoad(MessageResult message)
@@ -77,7 +82,17 @@ namespace TelegramBotBase.Form
         /// <param name="Id"></param>
         public void AddMessage(Message m)
         {
-            this.OldMessages.Add(m);
+            this.OldMessages.Add(m.MessageId);
+        }
+
+
+        /// <summary>
+        /// Adds a message to this of removable ones
+        /// </summary>
+        /// <param name="Id"></param>
+        public void AddMessage(int messageId)
+        {
+            this.OldMessages.Add(messageId);
         }
 
         /// <summary>
@@ -86,11 +101,7 @@ namespace TelegramBotBase.Form
         /// <param name="Id"></param>
         public void LeaveMessage(int Id)
         {
-            var m = this.OldMessages.FirstOrDefault(a => a.MessageId == Id);
+            this.OldMessages.Remove(Id);
-            if (m == null)
-                return;
-
-            this.OldMessages.Remove(m);
         }
 
         /// <summary>
@@ -118,15 +129,79 @@ namespace TelegramBotBase.Form
         /// <returns></returns>
         public async Task MessageCleanup()
         {
-            while (this.OldMessages.Count > 0)
+            var oldMessages = OldMessages.AsEnumerable();
+
+#if !NET472
+            while (oldMessages.Any())
             {
-                if (!await this.Device.DeleteMessage(this.OldMessages[0].MessageId))
+                using var cts = new CancellationTokenSource();
+                var deletedMessages = new ConcurrentBag<int>();
+                var parallelQuery = OldMessages.AsParallel()
+                                                .WithCancellation(cts.Token);
+                Task retryAfterTask = null;
+                try
                 {
-                    //Message can't be deleted cause it seems not to exist anymore
+                    parallelQuery.ForAll(i =>
-                    if (this.OldMessages.Count > 0)
+                    {
-                        this.OldMessages.RemoveAt(0);
+                        Device.DeleteMessage(i).GetAwaiter().GetResult();
+                        deletedMessages.Add(i);
+                    });
+                }
+                catch (AggregateException ex)
+                {
+                    cts.Cancel();
+
+                    var retryAfterSeconds = ex.InnerExceptions
+                        .Where(e => e is ApiRequestException apiEx && apiEx.ErrorCode == 429)
+                        .Max(e =>(int?) ((ApiRequestException)e).Parameters.RetryAfter) ?? 0;
+                    retryAfterTask = Task.Delay(retryAfterSeconds * 1000);
+                }
+                
+                deletedMessages.AsParallel().ForAll(i => Device.OnMessageDeleted(new MessageDeletedEventArgs(i)));
+
+                oldMessages = oldMessages.Where(x => !deletedMessages.Contains(x));
+                if (retryAfterTask != null)
+                    await retryAfterTask;
+            }
+#else
+            while (oldMessages.Any())
+            {
+                using (var cts = new CancellationTokenSource())
+                {
+                    var deletedMessages = new ConcurrentBag<int>();
+                    var parallelQuery = OldMessages.AsParallel()
+                                                    .WithCancellation(cts.Token);
+                    Task retryAfterTask = null;
+                    try
+                    {
+                        parallelQuery.ForAll(i =>
+                        {
+                            Device.DeleteMessage(i).GetAwaiter().GetResult();
+                            deletedMessages.Add(i);
+                        });
+                    }
+                    catch (AggregateException ex)
+                    {
+                        cts.Cancel();
+
+                        var retryAfterSeconds = ex.InnerExceptions
+                            .Where(e => e is ApiRequestException apiEx && apiEx.ErrorCode == 429)
+                            .Max(e => (int?)((ApiRequestException)e).Parameters.RetryAfter) ?? 0;
+                        retryAfterTask = Task.Delay(retryAfterSeconds * 1000);
+                    }
+
+                    deletedMessages.AsParallel().ForAll(i => Device.OnMessageDeleted(new MessageDeletedEventArgs(i)));
+
+                    oldMessages = oldMessages.Where(x => !deletedMessages.Contains(x));
+                    if (retryAfterTask != null)
+                        await retryAfterTask;
                 }
             }
+
+
+#endif
+
+            OldMessages.Clear();
         }
     }
 }

TelegramBotBase/Form/ButtonBase.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -7,12 +8,13 @@ using Telegram.Bot.Types.ReplyMarkups;
 
 namespace TelegramBotBase.Form
 {
+    [DebuggerDisplay("{Text}, {Value}")]
     /// <summary>
     /// Base class for button handling
     /// </summary>
     public class ButtonBase
     {
-        public String Text { get; set; }
+        public virtual String Text { get; set; }
 
         public String Value { get; set; }
 
@@ -36,7 +38,7 @@ namespace TelegramBotBase.Form
         /// </summary>
         /// <param name="form"></param>
         /// <returns></returns>
-        public InlineKeyboardButton ToInlineButton(ButtonForm form)
+        public virtual InlineKeyboardButton ToInlineButton(ButtonForm form)
         {
             String id = (form.DependencyControl != null ? form.DependencyControl.ControlID + "_" : "");
             if (this.Url == null)
@@ -59,7 +61,7 @@ namespace TelegramBotBase.Form
         /// </summary>
         /// <param name="form"></param>
         /// <returns></returns>
-        public KeyboardButton ToKeyboardButton(ButtonForm form)
+        public virtual KeyboardButton ToKeyboardButton(ButtonForm form)
         {
             return new KeyboardButton(this.Text);
         }

TelegramBotBase/Form/ButtonForm.cs

@@ -5,6 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using Telegram.Bot.Types.ReplyMarkups;
 using TelegramBotBase.Base;
+using TelegramBotBase.Controls.Hybrid;
 
 namespace TelegramBotBase.Form
 {
@@ -13,7 +14,7 @@ namespace TelegramBotBase.Form
     /// </summary>
     public class ButtonForm
     {
-        List<List<ButtonBase>> Buttons = new List<List<ButtonBase>>();
+        List<ButtonRow> Buttons = new List<ButtonRow>();
 
 
         public IReplyMarkup Markup { get; set; }
@@ -42,6 +43,15 @@ namespace TelegramBotBase.Form
             }
         }
 
+
+        public ButtonRow this[int row]
+        {
+            get
+            {
+                return Buttons[row];
+            }
+        }
+
         public ButtonForm()
         {
 
@@ -52,9 +62,19 @@ namespace TelegramBotBase.Form
             this.DependencyControl = control;
         }
 
-        public void AddButtonRow(IEnumerable<ButtonBase> row)
+        public void AddButtonRow(String Text, String Value, String Url = null)
         {
-            Buttons.Add(row.ToList());
+            Buttons.Add(new List<ButtonBase>() { new ButtonBase(Text, Value, Url) });
+        }
+
+        //public void AddButtonRow(ButtonRow row)
+        //{
+        //    Buttons.Add(row.ToList());
+        //}
+
+        public void AddButtonRow(ButtonRow row)
+        {
+            Buttons.Add(row);
         }
 
         public void AddButtonRow(params ButtonBase[] row)
@@ -62,6 +82,26 @@ namespace TelegramBotBase.Form
             AddButtonRow(row.ToList());
         }
 
+        public void AddButtonRows(IEnumerable<ButtonRow> rows)
+        {
+            Buttons.AddRange(rows);
+        }
+
+        public void InsertButtonRow(int index, IEnumerable<ButtonBase> row)
+        {
+            Buttons.Insert(index, row.ToList());
+        }
+
+        public void InsertButtonRow(int index, ButtonRow row)
+        {
+            Buttons.Insert(index, row);
+        }
+
+        //public void InsertButtonRow(int index, params ButtonBase[] row)
+        //{
+        //    InsertButtonRow(index, row.ToList());
+        //}
+
         public static T[][] SplitTo<T>(IEnumerable<T> items, int itemsPerRow = 2)
         {
             T[][] splitted = default(T[][]);
@@ -86,7 +126,10 @@ namespace TelegramBotBase.Form
         {
             get
             {
-                return this.Buttons.Select(a => a.ToArray()).Aggregate((a, b) => a.Union(b).ToArray()).Length;
+                if (this.Buttons.Count == 0)
+                    return 0;
+
+                return this.Buttons.Select(a => a.ToArray()).ToList().Aggregate((a, b) => a.Union(b).ToArray()).Length;
             }
         }
 
@@ -105,25 +148,62 @@ namespace TelegramBotBase.Form
             }
         }
 
+        /// <summary>
+        /// Returns a range of rows from the buttons.
+        /// </summary>
+        /// <param name="start"></param>
+        /// <param name="count"></param>
+        /// <returns></returns>
+        public List<ButtonRow> GetRange(int start, int count)
+        {
+            return Buttons.Skip(start).Take(count).ToList();
+        }
+
+
         public List<ButtonBase> ToList()
         {
-            return this.Buttons.Aggregate((a, b) => a.Union(b).ToList());
+            return this.Buttons.DefaultIfEmpty(new List<ButtonBase>()).Select(a => a.ToList()).Aggregate((a, b) => a.Union(b).ToList());
         }
 
         public InlineKeyboardButton[][] ToInlineButtonArray()
         {
-            var ikb = this.Buttons.Select(a => a.Select(b => b.ToInlineButton(this)).ToArray()).ToArray();
+            var ikb = this.Buttons.Select(a => a.ToArray().Select(b => b.ToInlineButton(this)).ToArray()).ToArray();
 
             return ikb;
         }
 
         public KeyboardButton[][] ToReplyButtonArray()
         {
-            var ikb = this.Buttons.Select(a => a.Select(b => b.ToKeyboardButton(this)).ToArray()).ToArray();
+            var ikb = this.Buttons.Select(a => a.ToArray().Select(b => b.ToKeyboardButton(this)).ToArray()).ToArray();
 
             return ikb;
         }
 
+        public List<ButtonRow> ToArray()
+        {
+            return Buttons;
+        }
+
+        public int FindRowByButton(ButtonBase button)
+        {
+            var row = this.Buttons.FirstOrDefault(a => a.ToArray().Count(b => b == button) > 0);
+            if (row == null)
+                return -1;
+
+            return this.Buttons.IndexOf(row);
+        }
+
+        public Tuple<ButtonRow, int> FindRow(String text, bool useText = true)
+        {
+            var r = this.Buttons.FirstOrDefault(a => a.Matches(text, useText));
+            if (r == null)
+                return null;
+
+            var i = this.Buttons.IndexOf(r);
+            return new Tuple<ButtonRow, int>(r, i);
+        }
+
+
         /// <summary>
         /// Returns the first Button with the given value.
         /// </summary>
@@ -153,5 +233,111 @@ namespace TelegramBotBase.Form
 
             return ikm;
         }
+
+        /// <summary>
+        /// Creates a copy of this form.
+        /// </summary>
+        /// <returns></returns>
+        public ButtonForm Duplicate()
+        {
+            var bf = new ButtonForm()
+            {
+                Markup = this.Markup,
+                DependencyControl = this.DependencyControl
+            };
+
+            foreach (var b in Buttons)
+            {
+                var lst = new ButtonRow();
+                foreach (var b2 in b)
+                {
+                    lst.Add(b2);
+                }
+                bf.Buttons.Add(lst);
+            }
+
+            return bf;
+        }
+
+        /// <summary>
+        /// Creates a copy of this form and filters by the parameter.
+        /// </summary>
+        /// <returns></returns>
+        public ButtonForm FilterDuplicate(String filter, bool ByRow = false)
+        {
+            var bf = new ButtonForm()
+            {
+                Markup = this.Markup,
+                DependencyControl = this.DependencyControl
+            };
+
+            foreach (var b in Buttons)
+            {
+                var lst = new ButtonRow();
+                foreach (var b2 in b)
+                {
+                    if (b2.Text.IndexOf(filter, StringComparison.InvariantCultureIgnoreCase) == -1)
+                        continue;
+
+                    //Copy full row, when at least one match has found.
+                    if (ByRow)
+                    {
+                        lst = b;
+                        break;
+                    }
+                    else
+                    {
+                        lst.Add(b2);
+                    }
+                }
+
+                if (lst.Count > 0)
+                    bf.Buttons.Add(lst);
+            }
+
+            return bf;
+        }
+
+        /// <summary>
+        /// Creates a copy of this form and filters by the parameter.
+        /// </summary>
+        /// <returns></returns>
+        public ButtonForm TagDuplicate(List<String> tags, bool ByRow = false)
+        {
+            var bf = new ButtonForm()
+            {
+                Markup = this.Markup,
+                DependencyControl = this.DependencyControl
+            };
+
+            foreach (var b in Buttons)
+            {
+                var lst = new ButtonRow();
+                foreach (var b2 in b)
+                {
+                    if (!(b2 is TagButtonBase tb))
+                        continue;
+
+                    if (!tags.Contains(tb.Tag))
+                        continue;
+
+                    //Copy full row, when at least one match has found.
+                    if (ByRow)
+                    {
+                        lst = b;
+                        break;
+                    }
+                    else
+                    {
+                        lst.Add(b2);
+                    }
+                }
+
+                if (lst.Count > 0)
+                    bf.Buttons.Add(lst);
+            }
+
+            return bf;
+        }
     }
 }

TelegramBotBase/Form/ConfirmDialog.cs

@@ -5,14 +5,28 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Args;
+using TelegramBotBase.Attributes;
 using TelegramBotBase.Base;
 
 namespace TelegramBotBase.Form
 {
+    [IgnoreState]
     public class ConfirmDialog : ModalDialog
     {
+        /// <summary>
+        /// The message the users sees.
+        /// </summary>
         public String Message { get; set; }
 
+        /// <summary>
+        /// An additional optional value.
+        /// </summary>
+        public object Tag { get; set; }
+
+        /// <summary>
+        /// Automatically close form on button click
+        /// </summary>
+        public bool AutoCloseOnClick { get; set; } = true;
 
         public List<ButtonBase> Buttons { get; set; }
 
@@ -48,6 +62,12 @@ namespace TelegramBotBase.Form
 
         public override async Task Action(MessageResult message)
         {
+            if (message.Handled)
+                return;
+
+            if (!message.IsFirstHandler)
+                return;
+
             var call = message.GetData<CallbackData>();
             if (call == null)
                 return;
@@ -65,7 +85,10 @@ namespace TelegramBotBase.Form
                 return;
             }
 
-            OnButtonClicked(new ButtonClickedEventArgs(button));
+            OnButtonClicked(new ButtonClickedEventArgs(button) { Tag = this.Tag });
+
+            if (AutoCloseOnClick)
+                await CloseForm();
         }
 
 

TelegramBotBase/Form/DynamicButton.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Form
+{
+    public class DynamicButton : ButtonBase
+    {
+        public override string Text
+        {
+            get
+            {
+                return GetText?.Invoke() ?? m_text;
+            }
+            set
+            {
+                m_text = value;
+            }
+        }
+
+        private String m_text = "";
+
+        private Func<String> GetText;
+
+        public DynamicButton(String Text, String Value, String Url = null)
+        {
+            this.Text = Text;
+            this.Value = Value;
+            this.Url = Url;
+        }
+
+        public DynamicButton(Func<String> GetText, String Value, String Url = null)
+        {
+            this.GetText = GetText;
+            this.Value = Value;
+            this.Url = Url;
+        }
+
+
+    }
+}

TelegramBotBase/Form/GroupForm.cs

@@ -5,7 +5,6 @@ using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Args;
 using TelegramBotBase.Base;
-using static TelegramBotBase.Base.Async;
 
 namespace TelegramBotBase.Form
 {
@@ -42,6 +41,7 @@ namespace TelegramBotBase.Form
                 case Telegram.Bot.Types.Enums.MessageType.MessagePinned:
                 case Telegram.Bot.Types.Enums.MessageType.GroupCreated:
                 case Telegram.Bot.Types.Enums.MessageType.SupergroupCreated:
+                case Telegram.Bot.Types.Enums.MessageType.ChannelCreated:
 
                     await OnGroupChanged(new GroupChangedEventArgs(message.MessageType, message));
 

TelegramBotBase/Form/ModalDialog.cs

@@ -22,7 +22,7 @@ namespace TelegramBotBase.Form
             await this.OnClosed(new EventArgs());
 
 
-            this.ParentForm?.ReturnFromModal(this);
+            await this.ParentForm?.ReturnFromModal(this);
         }
     }
 }

TelegramBotBase/Form/Navigation/NavigationController.cs

@@ -0,0 +1,358 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Args;
+using TelegramBotBase.Attributes;
+using TelegramBotBase.Base;
+using TelegramBotBase.Interfaces;
+
+namespace TelegramBotBase.Form.Navigation
+{
+    [DebuggerDisplay("{Index+1} Forms")]
+    public class NavigationController : FormBase, IStateForm
+    {
+
+        [SaveState]
+        private List<FormBase> History { get; set; }
+
+        [SaveState]
+        public int Index { get; set; }
+
+        /// <summary>
+        /// Will replace the controller when poping a form to the root form.
+        /// </summary>
+        [SaveState]
+        public bool ForceCleanupOnLastPop { get; set; }
+
+        public NavigationController()
+        {
+            History = new List<FormBase>();
+            Index = -1;
+            ForceCleanupOnLastPop = true;
+
+            this.Init += NavigationController_Init;
+            this.Opened += NavigationController_Opened;
+            this.Closed += NavigationController_Closed;
+        }
+
+        public NavigationController(FormBase startForm, params FormBase[] forms) : this()
+        {
+            this.Client = startForm.Client;
+            this.Device = startForm.Device;
+            startForm.NavigationController = this;
+
+            History.Add(startForm);
+            Index = 0;
+
+            if (forms.Length > 0)
+            {
+                History.AddRange(forms);
+                Index = History.Count - 1;
+            }
+        }
+
+        private async Task NavigationController_Init(object sender, Args.InitEventArgs e)
+        {
+            if (CurrentForm == null)
+                return;
+
+            await CurrentForm.OnInit(e);
+        }
+
+        private async Task NavigationController_Opened(object sender, EventArgs e)
+        {
+            if (CurrentForm == null)
+                return;
+
+            await CurrentForm.OnOpened(e);
+        }
+
+        private async Task NavigationController_Closed(object sender, EventArgs e)
+        {
+            if (CurrentForm == null)
+                return;
+
+            await CurrentForm.OnClosed(e);
+        }
+
+
+
+        /// <summary>
+        /// Remove the current active form on the stack.
+        /// </summary>
+        /// <returns></returns>
+        public virtual async Task PopAsync()
+        {
+            if (History.Count == 0)
+                return;
+
+            var form = History[Index];
+
+            form.NavigationController = null;
+            History.Remove(form);
+            Index--;
+
+            Device.FormSwitched = true;
+
+            await form.OnClosed(new EventArgs());
+
+            //Leave NavigationController and move to the last one
+            if (ForceCleanupOnLastPop && History.Count == 1)
+            {
+                var last_form = History[0];
+                last_form.NavigationController = null;
+                await this.NavigateTo(last_form);
+                return;
+            }
+
+            if (History.Count > 0)
+            {
+                form = History[Index];
+                await form.OnOpened(new EventArgs());
+            }
+        }
+
+        /// <summary>
+        /// Pop's through all forms back to the root form.
+        /// </summary>
+        /// <returns></returns>
+        public virtual async Task PopToRootAsync()
+        {
+            while (Index > 0)
+            {
+                await PopAsync();
+            }
+        }
+
+        /// <summary>
+        /// Pushing the given form to the stack and renders it.
+        /// </summary>
+        /// <param name="form"></param>
+        /// <returns></returns>
+        public virtual async Task PushAsync(FormBase form, params object[] args)
+        {
+            form.Client = this.Client;
+            form.Device = this.Device;
+            form.NavigationController = this;
+
+            this.History.Add(form);
+            Index++;
+
+            Device.FormSwitched = true;
+
+            if (Index < 2)
+                return;
+
+            await form.OnInit(new InitEventArgs(args));
+
+            await form.OnOpened(new EventArgs());
+        }
+
+        /// <summary>
+        /// Pops the current form and pushes a new one.
+        /// Will help to remove forms so you can not navigate back to them.
+        /// </summary>
+        /// <param name="form"></param>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        public virtual async Task PushAndReplaceAsync(FormBase form, params object[] args)
+        {
+            await PopAsync();
+
+            await PushAsync(form, args);
+        }
+
+        /// <summary>
+        /// Returns the current form from the stack.
+        /// </summary>
+        public FormBase CurrentForm
+        {
+            get
+            {
+                if (this.History.Count == 0)
+                    return null;
+
+                return this.History[Index];
+            }
+        }
+
+        public List<FormBase> GetAllForms()
+        {
+            return History.ToList();
+        }
+
+
+        public void LoadState(LoadStateEventArgs e)
+        {
+            if (e.Get("$controller.history.count") == null)
+                return;
+
+
+            int historyCount = e.GetInt("$controller.history.count");
+
+            for (int i = 0; i < historyCount; i++)
+            {
+
+                var c = e.GetObject($"$controller.history[{i}]") as Dictionary<String, object>;
+
+
+
+                var qname = e.Get($"$controller.history[{i}].type");
+
+                if (qname == null)
+                    continue;
+
+                Type t = Type.GetType(qname.ToString());
+                if (t == null || !t.IsSubclassOf(typeof(FormBase)))
+                {
+                    continue;
+                }
+
+                var form = t.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+                //No default constructor, fallback
+                if (form == null)
+                {
+                    continue;
+                }
+
+                var properties = c.Where(a => a.Key.StartsWith("$"));
+
+                var fields = form.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic).Where(a => a.GetCustomAttributes(typeof(SaveState), true).Length != 0).ToList();
+
+                foreach (var p in properties)
+                {
+                    var f = fields.FirstOrDefault(a => a.Name == p.Key.Substring(1));
+                    if (f == null)
+                        continue;
+
+                    try
+                    {
+                        if (f.PropertyType.IsEnum)
+                        {
+                            var ent = Enum.Parse(f.PropertyType, p.Value.ToString());
+
+                            f.SetValue(form, ent);
+
+                            continue;
+                        }
+
+
+                        f.SetValue(form, p.Value);
+                    }
+                    catch (ArgumentException ex)
+                    {
+
+                        Tools.Conversion.CustomConversionChecks(form, p, f);
+
+                    }
+                    catch
+                    {
+
+                    }
+                }
+
+                form.Device = this.Device;
+                form.Client = this.Client;
+                form.NavigationController = this;
+
+                form.OnInit(new InitEventArgs());
+
+                this.History.Add(form);
+            }
+
+        }
+
+        public void SaveState(SaveStateEventArgs e)
+        {
+            e.Set("$controller.history.count", History.Count.ToString());
+
+            int i = 0;
+            foreach (var form in History)
+            {
+                var fields = form.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic).Where(a => a.GetCustomAttributes(typeof(SaveState), true).Length != 0).ToList();
+
+                var dt = new Dictionary<String, object>();
+                foreach (var f in fields)
+                {
+                    var val = f.GetValue(form);
+
+                    dt.Add("$" + f.Name, val);
+                }
+
+                e.Set($"$controller.history[{i}].type", form.GetType().AssemblyQualifiedName);
+
+                e.SetObject($"$controller.history[{i}]", dt);
+
+                i++;
+            }
+        }
+
+
+        #region "Methods passthrough"
+
+        public override async Task NavigateTo(FormBase newForm, params object[] args)
+        {
+            await CurrentForm.NavigateTo(newForm, args);
+        }
+
+        public override async Task LoadControls(MessageResult message)
+        {
+            await CurrentForm.LoadControls(message);
+        }
+
+        public override async Task Load(MessageResult message)
+        {
+            await CurrentForm.Load(message);
+        }
+
+        public override async Task ActionControls(MessageResult message)
+        {
+            await CurrentForm.ActionControls(message);
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            await CurrentForm.Action(message);
+        }
+
+
+
+        public override async Task Edited(MessageResult message)
+        {
+            await CurrentForm.Edited(message);
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            await CurrentForm.Render(message);
+        }
+
+        public override async Task RenderControls(MessageResult message)
+        {
+            await CurrentForm.RenderControls(message);
+        }
+
+        public override async Task PreLoad(MessageResult message)
+        {
+            await CurrentForm.PreLoad(message);
+        }
+
+        public override async Task ReturnFromModal(ModalDialog modal)
+        {
+            await CurrentForm.ReturnFromModal(modal);
+        }
+
+        public override async Task SentData(DataResult message)
+        {
+            await CurrentForm.SentData(message);
+        }
+
+
+        #endregion
+
+    }
+}

TelegramBotBase/Form/PromptDialog.cs

@@ -4,24 +4,44 @@ using System.ComponentModel;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Telegram.Bot.Types;
 using Telegram.Bot.Types.ReplyMarkups;
+using TelegramBotBase.Args;
+using TelegramBotBase.Attributes;
 using TelegramBotBase.Base;
 
 namespace TelegramBotBase.Form
 {
+    [IgnoreState]
     public class PromptDialog : ModalDialog
     {
+        /// <summary>
+        /// The message the users sees.
+        /// </summary>
         public String Message { get; set; }
 
+        /// <summary>
+        /// The returned text value by the user.
+        /// </summary>
         public String Value { get; set; }
 
+        /// <summary>
+        /// An additional optional value.
+        /// </summary>
+        public object Tag { get; set; }
+
         private EventHandlerList __Events { get; set; } = new EventHandlerList();
 
         private static object __evCompleted { get; } = new object();
 
         public bool ShowBackButton { get; set; } = false;
 
-        public String BackLabel { get; set; } = "Zurück";
+        public String BackLabel { get; set; } = Localizations.Default.Language["PromptDialog_Back"];
+
+        /// <summary>
+        /// Contains the RAW received message.
+        /// </summary>
+        public Message ReceivedMessage { get; set; }
 
         public PromptDialog()
         {
@@ -38,6 +58,9 @@ namespace TelegramBotBase.Form
             if (message.Handled)
                 return;
 
+            if (!message.IsFirstHandler)
+                return;
+
             if (this.ShowBackButton && message.MessageText == BackLabel)
             {
                 await this.CloseForm();
@@ -48,6 +71,8 @@ namespace TelegramBotBase.Form
             if (this.Value == null)
             {
                 this.Value = message.MessageText;
+
+                ReceivedMessage = message.Message;
             }
 
 
@@ -71,13 +96,15 @@ namespace TelegramBotBase.Form
             }
 
 
-            OnCompleted(new EventArgs());
+            message.Handled = true;
+
+            OnCompleted(new PromptDialogCompletedEventArgs() { Tag = this.Tag, Value = this.Value });
 
             await this.CloseForm();
         }
 
 
-        public event EventHandler<EventArgs> Completed
+        public event EventHandler<PromptDialogCompletedEventArgs> Completed
         {
             add
             {
@@ -89,9 +116,9 @@ namespace TelegramBotBase.Form
             }
         }
 
-        public void OnCompleted(EventArgs e)
+        public void OnCompleted(PromptDialogCompletedEventArgs e)
         {
-            (this.__Events[__evCompleted] as EventHandler<EventArgs>)?.Invoke(this, e);
+            (this.__Events[__evCompleted] as EventHandler<PromptDialogCompletedEventArgs>)?.Invoke(this, e);
         }
 
     }

TelegramBotBase/Form/SplitterForm.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Base;
-using static TelegramBotBase.Base.Async;
+
 
 namespace TelegramBotBase.Form
 {

TelegramBotBase/Form/TagButtonBase.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace TelegramBotBase.Form
+{
+    /// <summary>
+    /// Base class for button handling
+    /// </summary>
+    public class TagButtonBase : ButtonBase
+    {
+        public String Tag { get; set; }
+
+        public TagButtonBase()
+        {
+
+        }
+
+        public TagButtonBase(String Text, String Value, String Tag)
+        {
+            this.Text = Text;
+            this.Value = Value;
+            this.Tag = Tag;
+        }
+
+
+        /// <summary>
+        /// Returns an inline Button
+        /// </summary>
+        /// <param name="form"></param>
+        /// <returns></returns>
+        public override InlineKeyboardButton ToInlineButton(ButtonForm form)
+        {
+            String id = (form.DependencyControl != null ? form.DependencyControl.ControlID + "_" : "");
+
+            return InlineKeyboardButton.WithCallbackData(this.Text, id + this.Value);
+
+        }
+
+
+        /// <summary>
+        /// Returns a KeyBoardButton
+        /// </summary>
+        /// <param name="form"></param>
+        /// <returns></returns>
+        public override KeyboardButton ToKeyboardButton(ButtonForm form)
+        {
+            return new KeyboardButton(this.Text);
+        }
+
+    }
+}

TelegramBotBase/Interfaces/IDataSource.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using TelegramBotBase.Controls.Hybrid;
+
+namespace TelegramBotBase.Interfaces
+{
+    public interface IDataSource<T>
+    {
+
+        /// <summary>
+        /// Returns the amount of items within this source.
+        /// </summary>
+        /// <returns></returns>
+        int Count { get; }
+
+
+        /// <summary>
+        /// Returns the item at the specific index.
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        T ItemAt(int index);
+
+
+        /// <summary>
+        /// Get all items from this source within this range.
+        /// </summary>
+        /// <param name="start"></param>
+        /// <param name="count"></param>
+        /// <returns></returns>
+        List<T> ItemRange(int start, int count);
+
+
+        /// <summary>
+        /// Gets a list of all items of this datasource.
+        /// </summary>
+        /// <returns></returns>
+        List<T> AllItems();
+
+
+    }
+}

TelegramBotBase/Interfaces/IDeviceSession.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Interfaces
+{
+    interface IDeviceSession
+    {
+        /// <summary>
+        /// Device or chat id
+        /// </summary>
+        long DeviceId { get; set; }
+
+        /// <summary>
+        /// Username of user or group
+        /// </summary>
+        String ChatTitle { get; set; }
+
+
+        /// <summary>
+        /// When did any last action happend (message received or button clicked)
+        /// </summary>
+        DateTime LastAction { get; set; }
+
+        /// <summary>
+        /// Returns the form where the user/group is at the moment.
+        /// </summary>
+        FormBase ActiveForm { get; set; }
+
+        /// <summary>
+        /// Returns the previous shown form
+        /// </summary>
+        FormBase PreviousForm { get; set; }
+
+        /// <summary>
+        /// contains if the form has been switched (navigated)
+        /// </summary>
+        bool FormSwitched { get; set; }
+
+    }
+}

TelegramBotBase/Interfaces/IStateMachine.cs

@@ -3,11 +3,14 @@ using System.Collections.Generic;
 using System.Text;
 using TelegramBotBase.Args;
 using TelegramBotBase.Base;
+using TelegramBotBase.Form;
 
 namespace TelegramBotBase.Interfaces
 {
     public interface IStateMachine
     {
+        Type FallbackStateForm { get; }
+
         void SaveFormStates(SaveStatesEventArgs e);
 
         StateContainer LoadFormStates();

TelegramBotBase/Localizations/Default.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Localizations
+{
+    public static class Default
+    {
+
+        public static Localization Language = new English();
+
+
+    }
+}

TelegramBotBase/Localizations/English.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Localizations
+{
+    public class English : Localization
+    {
+        public English() : base()
+        {
+            Values["Language"] = "English";
+            Values["ButtonGrid_Title"] = "Menu";
+            Values["ButtonGrid_NoItems"] = "There are no items.";
+            Values["ButtonGrid_PreviousPage"] = "◀️";
+            Values["ButtonGrid_NextPage"] = "▶️";
+            Values["ButtonGrid_CurrentPage"] = "Page {0} of {1}";
+            Values["ButtonGrid_SearchFeature"] = "💡 Send a message to filter the list. Click the 🔍 to reset the filter.";
+            Values["ButtonGrid_Back"] = "Back";
+            Values["ButtonGrid_CheckAll"] = "Check all";
+            Values["ButtonGrid_UncheckAll"] = "Uncheck all";
+            Values["CalendarPicker_Title"] = "Pick date";
+            Values["CalendarPicker_PreviousPage"] = "◀️";
+            Values["CalendarPicker_NextPage"] = "▶️";
+            Values["TreeView_Title"] = "Select node";
+            Values["TreeView_LevelUp"] = "🔼 level up";
+            Values["ToggleButton_On"] = "On";
+            Values["ToggleButton_Off"] = "Off";
+            Values["ToggleButton_OnIcon"] = "⚫";
+            Values["ToggleButton_OffIcon"] = "⚪";
+            Values["ToggleButton_Title"] = "Toggle";
+            Values["ToggleButton_Changed"] = "Choosen";
+            Values["MultiToggleButton_SelectedIcon"] = "✅";
+            Values["MultiToggleButton_Title"] = "Multi-Toggle";
+            Values["MultiToggleButton_Changed"] = "Choosen";
+            Values["PromptDialog_Back"] = "Back";
+            Values["ToggleButton_Changed"] = "Setting changed";
+        }
+
+
+    }
+}

TelegramBotBase/Localizations/German.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Localizations
+{
+    public class German : Localization
+    {
+        public German() : base()
+        {
+            Values["Language"] = "Deutsch (German)";
+            Values["ButtonGrid_Title"] = "Menü";
+            Values["ButtonGrid_NoItems"] = "Es sind keine Einträge vorhanden.";
+            Values["ButtonGrid_PreviousPage"] = "◀️";
+            Values["ButtonGrid_NextPage"] = "▶️";
+            Values["ButtonGrid_CurrentPage"] = "Seite {0} von {1}";
+            Values["ButtonGrid_SearchFeature"] = "💡 Sende eine Nachricht um die Liste zu filtern. Klicke die 🔍 um den Filter zurückzusetzen.";
+            Values["ButtonGrid_Back"] = "Zurück";
+            Values["ButtonGrid_CheckAll"] = "Alle auswählen";
+            Values["ButtonGrid_UncheckAll"] = "Keine auswählen";
+            Values["CalendarPicker_Title"] = "Datum auswählen";
+            Values["CalendarPicker_PreviousPage"] = "◀️";
+            Values["CalendarPicker_NextPage"] = "▶️";
+            Values["TreeView_Title"] = "Knoten auswählen";
+            Values["TreeView_LevelUp"] = "🔼 Stufe hoch";
+            Values["ToggleButton_On"] = "An";
+            Values["ToggleButton_Off"] = "Aus";
+            Values["ToggleButton_OnIcon"] = "⚫";
+            Values["ToggleButton_OffIcon"] = "⚪";
+            Values["ToggleButton_Title"] = "Schalter";
+            Values["ToggleButton_Changed"] = "Ausgewählt";
+            Values["MultiToggleButton_SelectedIcon"] = "✅";
+            Values["MultiToggleButton_Title"] = "Mehrfach-Schalter";
+            Values["MultiToggleButton_Changed"] = "Ausgewählt";
+            Values["PromptDialog_Back"] = "Zurück";
+            Values["ToggleButton_Changed"] = "Einstellung geändert";
+        }
+
+
+    }
+}

TelegramBotBase/Localizations/Localization.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Localizations
+{
+    public abstract class Localization
+    {
+        public Dictionary<String, String> Values = new Dictionary<string, string>();
+
+        public String this[String key]
+        {
+            get
+            {
+                return Values[key];
+            }
+        }
+
+        public Localization()
+        {
+            
+            
+        }
+
+    }
+}
+

TelegramBotBase/Properties/AssemblyInfo.cs

@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Florian Dahn")]
 [assembly: AssemblyProduct("TelegramBotBase Framework")]
-[assembly: AssemblyCopyright("Copyright © Florian Dahn 2019")]
+[assembly: AssemblyCopyright("Copyright © Florian Dahn 2020")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern 
 // übernehmen, indem Sie "*" eingeben:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.1.0.0")]
+[assembly: AssemblyVersion("3.1.0.0")]
-[assembly: AssemblyFileVersion("2.1.0.0")]
+[assembly: AssemblyFileVersion("3.1.0.0")]

TelegramBotBase/SessionBase.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using System.Runtime.Serialization;
 using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Args;
@@ -14,12 +16,15 @@ namespace TelegramBotBase
     /// <summary>
     /// Base class for managing all active sessions
     /// </summary>
-    public class SessionBase
+    public class SessionBase<T>
+        where T : FormBase
     {
         public MessageClient Client { get; set; }
 
         public Dictionary<long, DeviceSession> SessionList { get; set; }
 
+        public BotBase<T> BotBase { get; set; }
+
 
         public SessionBase()
         {
@@ -88,7 +93,7 @@ namespace TelegramBotBase
             if (d != null)
             {
                 this.SessionList.Remove(deviceId);
-                
+
             }
         }
 
@@ -110,6 +115,20 @@ namespace TelegramBotBase
             return this.SessionList.Where(a => a.Key < 0).Select(a => a.Value).ToList();
         }
 
+        /// <summary>
+        /// Loads the previously saved states from the machine.
+        /// </summary>
+        public async void LoadSessionStates()
+        {
+            if (BotBase.StateMachine == null)
+            {
+                return;
+            }
+
+            LoadSessionStates(BotBase.StateMachine);
+        }
+
+
         /// <summary>
         /// Loads the previously saved states from the machine.
         /// </summary>
@@ -130,7 +149,26 @@ namespace TelegramBotBase
                     continue;
                 }
 
-                var form = t.GetConstructor(new Type[] { }).Invoke(new object[] { }) as FormBase;
+                //Key already existing
+                if (this.SessionList.ContainsKey(s.DeviceId))
+                    continue;
+
+                var form = t.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+                //No default constructor, fallback
+                if (form == null)
+                {
+                    if (!statemachine.FallbackStateForm.IsSubclassOf(typeof(FormBase)))
+                        continue;
+
+                    form = statemachine.FallbackStateForm.GetConstructor(new Type[] { })?.Invoke(new object[] { }) as FormBase;
+
+                    //Fallback failed, due missing default constructor
+                    if (form == null)
+                        continue;
+
+                }
+
 
                 if (s.Values != null && s.Values.Count > 0)
                 {
@@ -145,11 +183,23 @@ namespace TelegramBotBase
 
                         try
                         {
+                            if (f.PropertyType.IsEnum)
+                            {
+                                var ent = Enum.Parse(f.PropertyType, p.Value.ToString());
+
+                                f.SetValue(form, ent);
+
+                                continue;
+                            }
+
+
                             f.SetValue(form, p.Value);
                         }
                         catch (ArgumentException ex)
                         {
 
+                            Tools.Conversion.CustomConversionChecks(form, p, f);
+
                         }
                         catch
                         {
@@ -158,6 +208,13 @@ namespace TelegramBotBase
                     }
                 }
 
+                form.Client = Client;
+                var device = new DeviceSession(s.DeviceId, form);
+
+                device.ChatTitle = s.ChatTitle;
+
+                this.SessionList.Add(s.DeviceId, device);
+
                 //Is Subclass of IStateForm
                 var iform = form as IStateForm;
                 if (iform != null)
@@ -167,14 +224,6 @@ namespace TelegramBotBase
                     iform.LoadState(ls);
                 }
 
-
-                form.Client = Client;
-                var device = new DeviceSession(s.DeviceId, form);
-
-                device.ChatTitle = s.ChatTitle;
-
-                this.SessionList.Add(s.DeviceId, device);
-
                 try
                 {
                     await form.OnInit(new InitEventArgs());
@@ -190,6 +239,9 @@ namespace TelegramBotBase
 
         }
 
+       
+
+
         /// <summary>
         /// Saves all open states into the machine.
         /// </summary>
@@ -211,19 +263,26 @@ namespace TelegramBotBase
 
                 var form = s.Value.ActiveForm;
 
-
                 try
                 {
                     var se = new StateEntry();
                     se.DeviceId = s.Key;
-                    se.ChatTitle = s.Value.ChatTitle;
+                    se.ChatTitle = s.Value.GetChatTitle();
                     se.FormUri = form.GetType().FullName;
                     se.QualifiedName = form.GetType().AssemblyQualifiedName;
 
                     //Skip classes where IgnoreState attribute is existing
                     if (form.GetType().GetCustomAttributes(typeof(IgnoreState), true).Length != 0)
                     {
-                        continue;
+                        //Skip this form, when there is no fallback state form
+                        if (statemachine.FallbackStateForm == null)
+                        {
+                            continue;
+                        }
+
+                        //Replace form by default State one.
+                        se.FormUri = statemachine.FallbackStateForm.FullName;
+                        se.QualifiedName = statemachine.FallbackStateForm.AssemblyQualifiedName;
                     }
 
                     //Is Subclass of IStateForm
@@ -261,5 +320,17 @@ namespace TelegramBotBase
 
             statemachine.SaveFormStates(new SaveStatesEventArgs(sc));
         }
+
+        /// <summary>
+        /// Saves all open states into the machine.
+        /// </summary>
+        public void SaveSessionStates()
+        {
+            if (this.BotBase.StateMachine == null)
+                return;
+
+
+            this.SaveSessionStates(this.BotBase.StateMachine);
+        }
     }
 }

TelegramBotBase/Sessions/DeviceSession.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.IO;
@@ -16,6 +17,7 @@ using TelegramBotBase.Args;
 using TelegramBotBase.Base;
 using TelegramBotBase.Exceptions;
 using TelegramBotBase.Form;
+using TelegramBotBase.Interfaces;
 using TelegramBotBase.Markdown;
 
 namespace TelegramBotBase.Sessions
@@ -23,7 +25,7 @@ namespace TelegramBotBase.Sessions
     /// <summary>
     /// Base class for a device/chat session
     /// </summary>
-    public class DeviceSession
+    public class DeviceSession : IDeviceSession
     {
         /// <summary>
         /// Device or chat id
@@ -35,6 +37,18 @@ namespace TelegramBotBase.Sessions
         /// </summary>
         public String ChatTitle { get; set; }
 
+        /// <summary>
+        /// Returns the ChatTitle depending on groups/channels or users
+        /// </summary>
+        /// <returns></returns>
+        public String GetChatTitle()
+        {
+            return LastMessage?.Chat.Title
+                ?? LastMessage?.Chat.Username
+                ?? LastMessage?.Chat.FirstName
+                ?? ChatTitle;
+        }
+
         /// <summary>
         /// When did any last action happend (message received or button clicked)
         /// </summary>
@@ -105,6 +119,7 @@ namespace TelegramBotBase.Sessions
 
         private static object __evMessageSent = new object();
         private static object __evMessageReceived = new object();
+        private static object __evMessageDeleted = new object();
 
         public DeviceSession()
         {
@@ -123,6 +138,7 @@ namespace TelegramBotBase.Sessions
             this.ActiveForm.Device = this;
         }
 
+
         /// <summary>
         /// Edits the text message
         /// </summary>
@@ -130,11 +146,8 @@ namespace TelegramBotBase.Sessions
         /// <param name="text"></param>
         /// <param name="buttons"></param>
         /// <returns></returns>
-        public async Task<Message> Edit(int messageId, String text, ButtonForm buttons = null)
+        public async Task<Message> Edit(int messageId, String text, ButtonForm buttons = null, ParseMode parseMode = ParseMode.Default)
         {
-            if (this.ActiveForm == null)
-                return null;
-
             InlineKeyboardMarkup markup = buttons;
 
             if (text.Length > Constants.Telegram.MaxMessageLength)
@@ -144,7 +157,7 @@ namespace TelegramBotBase.Sessions
 
             try
             {
-                return await this.Client.TelegramClient.EditMessageTextAsync(this.DeviceId, messageId, text, replyMarkup: markup);
+                return await API(a => a.EditMessageTextAsync(this.DeviceId, messageId, text, parseMode, replyMarkup: markup));
             }
             catch
             {
@@ -162,11 +175,8 @@ namespace TelegramBotBase.Sessions
         /// <param name="text"></param>
         /// <param name="buttons"></param>
         /// <returns></returns>
-        public async Task<Message> Edit(int messageId, String text, InlineKeyboardMarkup markup)
+        public async Task<Message> Edit(int messageId, String text, InlineKeyboardMarkup markup, ParseMode parseMode = ParseMode.Default)
         {
-            if (this.ActiveForm == null)
-                return null;
-
             if (text.Length > Constants.Telegram.MaxMessageLength)
             {
                 throw new MaxLengthException(text.Length);
@@ -174,7 +184,7 @@ namespace TelegramBotBase.Sessions
 
             try
             {
-                return await this.Client.TelegramClient.EditMessageTextAsync(this.DeviceId, messageId, text, replyMarkup: markup);
+                return await API(a => a.EditMessageTextAsync(this.DeviceId, messageId, text, parseMode, replyMarkup: markup));
             }
             catch
             {
@@ -192,11 +202,8 @@ namespace TelegramBotBase.Sessions
         /// <param name="text"></param>
         /// <param name="buttons"></param>
         /// <returns></returns>
-        public async Task<Message> Edit(Message message, ButtonForm buttons = null)
+        public async Task<Message> Edit(Message message, ButtonForm buttons = null, ParseMode parseMode = ParseMode.Default)
         {
-            if (this.ActiveForm == null)
-                return null;
-
             InlineKeyboardMarkup markup = buttons;
 
             if (message.Text.Length > Constants.Telegram.MaxMessageLength)
@@ -206,7 +213,7 @@ namespace TelegramBotBase.Sessions
 
             try
             {
-                return await this.Client.TelegramClient.EditMessageTextAsync(this.DeviceId, message.MessageId, message.Text, replyMarkup: markup);
+                return await API(a => a.EditMessageTextAsync(this.DeviceId, message.MessageId, message.Text, parseMode, replyMarkup: markup));
             }
             catch
             {
@@ -217,6 +224,27 @@ namespace TelegramBotBase.Sessions
             return null;
         }
 
+        /// <summary>
+        /// Edits the reply keyboard markup (buttons)
+        /// </summary>
+        /// <param name="messageId"></param>
+        /// <param name="bf"></param>
+        /// <returns></returns>
+        public async Task<Message> EditReplyMarkup(int messageId, ButtonForm bf)
+        {
+
+            try
+            {
+                return await API(a => a.EditMessageReplyMarkupAsync(this.DeviceId, messageId, bf));
+            }
+            catch
+            {
+
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Sends a simple text message
         /// </summary>
@@ -225,15 +253,13 @@ namespace TelegramBotBase.Sessions
         /// <param name="replyTo"></param>
         /// <param name="disableNotification"></param>
         /// <returns></returns>
-        public async Task<Message> Send(String text, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false, ParseMode parseMode = ParseMode.Default, bool MarkdownV2AutoEscape = true)
+        public async Task<Message> Send(long deviceId, String text, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false, ParseMode parseMode = ParseMode.Default, bool MarkdownV2AutoEscape = true)
         {
             if (this.ActiveForm == null)
                 return null;
 
             InlineKeyboardMarkup markup = buttons;
 
-            Message m = null;
-
             if (text.Length > Constants.Telegram.MaxMessageLength)
             {
                 throw new MaxLengthException(text.Length);
@@ -246,20 +272,30 @@ namespace TelegramBotBase.Sessions
 
             try
             {
-                m = await (this.Client.TelegramClient.SendTextMessageAsync(this.DeviceId, text, parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
+                var t = API(a => a.SendTextMessageAsync(deviceId, text, parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
 
-                OnMessageSent(new MessageSentEventArgs(m));
+                var o = GetOrigin(new StackTrace());
-            }
+                OnMessageSent(new MessageSentEventArgs(await t, o));
-            catch (ApiRequestException)
+
-            {
+                return await t;
-                return null;
             }
             catch
             {
                 return null;
             }
+        }
 
-            return m;
+        /// <summary>
+        /// Sends a simple text message
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="buttons"></param>
+        /// <param name="replyTo"></param>
+        /// <param name="disableNotification"></param>
+        /// <returns></returns>
+        public async Task<Message> Send(String text, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false, ParseMode parseMode = ParseMode.Default, bool MarkdownV2AutoEscape = true)
+        {
+            return await Send(this.DeviceId, text, buttons, replyTo, disableNotification, parseMode, MarkdownV2AutoEscape);
         }
 
         /// <summary>
@@ -275,8 +311,6 @@ namespace TelegramBotBase.Sessions
             if (this.ActiveForm == null)
                 return null;
 
-            Message m = null;
-
             if (text.Length > Constants.Telegram.MaxMessageLength)
             {
                 throw new MaxLengthException(text.Length);
@@ -289,20 +323,17 @@ namespace TelegramBotBase.Sessions
 
             try
             {
-                m = await (this.Client.TelegramClient.SendTextMessageAsync(this.DeviceId, text, parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
+                var t = API(a => a.SendTextMessageAsync(this.DeviceId, text, parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
 
-                OnMessageSent(new MessageSentEventArgs(m));
+                var o = GetOrigin(new StackTrace());
-            }
+                OnMessageSent(new MessageSentEventArgs(await t, o));
-            catch (ApiRequestException)
+
-            {
+                return await t;
-                return null;
             }
             catch
             {
                 return null;
             }
-
-            return m;
         }
 
         /// <summary>
@@ -318,8 +349,6 @@ namespace TelegramBotBase.Sessions
             if (this.ActiveForm == null)
                 return null;
 
-            Message m = null;
-
             if (text.Length > Constants.Telegram.MaxMessageLength)
             {
                 throw new MaxLengthException(text.Length);
@@ -332,20 +361,17 @@ namespace TelegramBotBase.Sessions
 
             try
             {
-                m = await (this.Client.TelegramClient.SendTextMessageAsync(this.DeviceId, text, parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
+                var t = API(a => a.SendTextMessageAsync(this.DeviceId, text, parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
 
-                OnMessageSent(new MessageSentEventArgs(m));
+                var o = GetOrigin(new StackTrace());
-            }
+                OnMessageSent(new MessageSentEventArgs(await t, o));
-            catch (ApiRequestException)
+
-            {
+                return await t;
-                return null;
             }
             catch
             {
                 return null;
             }
-
-            return m;
         }
 
         /// <summary>
@@ -356,31 +382,26 @@ namespace TelegramBotBase.Sessions
         /// <param name="replyTo"></param>
         /// <param name="disableNotification"></param>
         /// <returns></returns>
-        public async Task<Message> SendPhoto(InputOnlineFile file, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false, ParseMode parseMode = ParseMode.Default)
+        public async Task<Message> SendPhoto(InputOnlineFile file, String caption = null, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false, ParseMode parseMode = ParseMode.Default)
         {
             if (this.ActiveForm == null)
                 return null;
 
             InlineKeyboardMarkup markup = buttons;
 
-            Message m = null;
-
             try
             {
-                m = await this.Client.TelegramClient.SendPhotoAsync(this.DeviceId, file, parseMode: parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification);
+                var t = API(a => a.SendPhotoAsync(this.DeviceId, file, caption: caption, parseMode: parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
 
-                OnMessageSent(new MessageSentEventArgs(m));
+                var o = GetOrigin(new StackTrace());
-            }
+                OnMessageSent(new MessageSentEventArgs(await t, o));
-            catch (ApiRequestException)
+
-            {
+                return await t;
-                return null;
             }
             catch
             {
                 return null;
             }
-
-            return m;
         }
 
         /// <summary>
@@ -392,13 +413,13 @@ namespace TelegramBotBase.Sessions
         /// <param name="replyTo"></param>
         /// <param name="disableNotification"></param>
         /// <returns></returns>
-        public async Task<Message> SendPhoto(Image image, String name, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false)
+        public async Task<Message> SendPhoto(Image image, String name, String caption, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false)
         {
             using (var fileStream = Tools.Images.ToStream(image, ImageFormat.Png))
             {
                 InputOnlineFile fts = new InputOnlineFile(fileStream, name);
 
-                return await SendPhoto(fts, buttons, replyTo, disableNotification);
+                return await SendPhoto(fts, caption: caption, buttons, replyTo, disableNotification);
             }
         }
 
@@ -411,13 +432,13 @@ namespace TelegramBotBase.Sessions
         /// <param name="replyTo"></param>
         /// <param name="disableNotification"></param>
         /// <returns></returns>
-        public async Task<Message> SendPhoto(Bitmap image, String name, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false)
+        public async Task<Message> SendPhoto(Bitmap image, String name, String caption, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false)
         {
             using (var fileStream = Tools.Images.ToStream(image, ImageFormat.Png))
             {
                 InputOnlineFile fts = new InputOnlineFile(fileStream, name);
 
-                return await SendPhoto(fts, buttons, replyTo, disableNotification);
+                return await SendPhoto(fts, caption: caption, buttons, replyTo, disableNotification);
             }
         }
 
@@ -429,31 +450,26 @@ namespace TelegramBotBase.Sessions
         /// <param name="replyTo"></param>
         /// <param name="disableNotification"></param>
         /// <returns></returns>
-        public async Task<Message> SendVideo(InputOnlineFile file, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false, ParseMode parseMode = ParseMode.Default)
+        public async Task<Message> SendVideo(InputOnlineFile file, String caption = null, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false, ParseMode parseMode = ParseMode.Default)
         {
             if (this.ActiveForm == null)
                 return null;
 
             InlineKeyboardMarkup markup = buttons;
 
-            Message m = null;
-
             try
             {
-                m = await this.Client.TelegramClient.SendVideoAsync(this.DeviceId, file, parseMode: parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification);
+                var t = API(a => a.SendVideoAsync(this.DeviceId, file, caption: caption, parseMode: parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
 
-                OnMessageSent(new MessageSentEventArgs(m));
+                var o = GetOrigin(new StackTrace());
-            }
+                OnMessageSent(new MessageSentEventArgs(await t, o));
-            catch (ApiRequestException)
+
-            {
+                return await t;
-                return null;
             }
             catch
             {
                 return null;
             }
-
-            return m;
         }
 
         /// <summary>
@@ -471,24 +487,19 @@ namespace TelegramBotBase.Sessions
 
             InlineKeyboardMarkup markup = buttons;
 
-            Message m = null;
-
             try
             {
-                m = await this.Client.TelegramClient.SendVideoAsync(this.DeviceId, new InputOnlineFile(url), parseMode: parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification);
+                var t = API(a => a.SendVideoAsync(this.DeviceId, new InputOnlineFile(url), parseMode: parseMode, replyToMessageId: replyTo, replyMarkup: markup, disableNotification: disableNotification));
 
-                OnMessageSent(new MessageSentEventArgs(m));
+                var o = GetOrigin(new StackTrace());
-            }
+                OnMessageSent(new MessageSentEventArgs(await t, o));
-            catch (ApiRequestException)
+
-            {
+                return await t;
-                return null;
             }
             catch
             {
                 return null;
             }
-
-            return m;
         }
 
         /// <summary>
@@ -553,11 +564,19 @@ namespace TelegramBotBase.Sessions
                 markup = buttons;
             }
 
-            var m = await this.Client.TelegramClient.SendDocumentAsync(this.DeviceId, document, caption, replyMarkup: markup, disableNotification: disableNotification, replyToMessageId: replyTo);
+            try
+            {
+                var t = API(a => a.SendDocumentAsync(this.DeviceId, document, caption, replyMarkup: markup, disableNotification: disableNotification, replyToMessageId: replyTo));
 
-            OnMessageSent(new MessageSentEventArgs(m));
+                var o = GetOrigin(new StackTrace());
+                OnMessageSent(new MessageSentEventArgs(await t, o));
 
-            return m;
+                return await t;
+            }
+            catch
+            {
+                return null;
+            }
         }
 
         /// <summary>
@@ -567,7 +586,7 @@ namespace TelegramBotBase.Sessions
         /// <returns></returns>
         public async Task SetAction(ChatAction action)
         {
-            await this.Client.TelegramClient.SendChatActionAsync(this.DeviceId, action);
+            await API(a => a.SendChatActionAsync(this.DeviceId, action));
         }
 
         /// <summary>
@@ -581,7 +600,7 @@ namespace TelegramBotBase.Sessions
         {
             var rck = new ReplyKeyboardMarkup(KeyboardButton.WithRequestContact(buttonText));
             rck.OneTimeKeyboard = OneTimeOnly;
-            return await this.Client.TelegramClient.SendTextMessageAsync(this.DeviceId, requestMessage, replyMarkup: rck);
+            return await API(a => a.SendTextMessageAsync(this.DeviceId, requestMessage, replyMarkup: rck));
         }
 
         /// <summary>
@@ -595,7 +614,7 @@ namespace TelegramBotBase.Sessions
         {
             var rcl = new ReplyKeyboardMarkup(KeyboardButton.WithRequestLocation(buttonText));
             rcl.OneTimeKeyboard = OneTimeOnly;
-            return await this.Client.TelegramClient.SendTextMessageAsync(this.DeviceId, requestMessage, replyMarkup: rcl);
+            return await API(a => a.SendTextMessageAsync(this.DeviceId, requestMessage, replyMarkup: rcl));
         }
 
         public async Task<Message> HideReplyKeyboard(String closedMsg = "Closed", bool autoDeleteResponse = true)
@@ -627,7 +646,7 @@ namespace TelegramBotBase.Sessions
         {
             try
             {
-                await this.Client.TelegramClient.DeleteMessageAsync(this.DeviceId, messageId);
+                await RAW(a => a.DeleteMessageAsync(this.DeviceId, messageId));
 
                 return true;
             }
@@ -654,7 +673,7 @@ namespace TelegramBotBase.Sessions
         {
             try
             {
-                await this.Client.TelegramClient.SetChatPermissionsAsync(this.DeviceId, permissions);
+                await API(a => a.SetChatPermissionsAsync(this.DeviceId, permissions));
             }
             catch
             {
@@ -662,11 +681,30 @@ namespace TelegramBotBase.Sessions
             }
         }
 
-        public virtual async Task RestrictUser(int userId, ChatPermissions permissions, DateTime until = default(DateTime))
+        private Type GetOrigin(StackTrace stackTrace)
+        {
+            for (int i = 0; i < stackTrace.FrameCount; i++)
+            {
+                var methodBase = stackTrace.GetFrame(i).GetMethod();
+
+                //Debug.WriteLine(methodBase.Name);
+
+                if (methodBase.DeclaringType.IsSubclassOf(typeof(FormBase)) | methodBase.DeclaringType.IsSubclassOf(typeof(ControlBase)))
+                {
+                    return methodBase.DeclaringType;
+                }
+            }
+
+            return null;
+        }
+
+        #region "Users"
+
+        public virtual async Task RestrictUser(long userId, ChatPermissions permissions, DateTime until = default(DateTime))
         {
             try
             {
-                await this.Client.TelegramClient.RestrictChatMemberAsync(this.DeviceId, userId, permissions, until);
+                await API(a => a.RestrictChatMemberAsync(this.DeviceId, userId, permissions, until));
             }
             catch
             {
@@ -674,11 +712,11 @@ namespace TelegramBotBase.Sessions
             }
         }
 
-        public virtual async Task<ChatMember> GetChatUser(int userId)
+        public virtual async Task<ChatMember> GetChatUser(long userId)
         {
             try
             {
-                return await this.Client.TelegramClient.GetChatMemberAsync(this.DeviceId, userId);
+                return await API(a => a.GetChatMemberAsync(this.DeviceId, userId));
             }
             catch
             {
@@ -687,11 +725,11 @@ namespace TelegramBotBase.Sessions
             return null;
         }
 
-        public virtual async Task KickUser(int userId, DateTime until = default(DateTime))
+        public virtual async Task KickUser(long userId, DateTime until = default(DateTime))
         {
             try
             {
-                await this.Client.TelegramClient.KickChatMemberAsync(this.DeviceId, userId, until);
+                await API(a => a.KickChatMemberAsync(this.DeviceId, userId, until));
             }
             catch
             {
@@ -699,6 +737,90 @@ namespace TelegramBotBase.Sessions
             }
         }
 
+        public virtual async Task UnbanUser(long userId)
+        {
+            try
+            {
+                await API(a => a.UnbanChatMemberAsync(this.DeviceId, userId));
+            }
+            catch
+            {
+
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Gives access to the original TelegramClient without any Exception catchings.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="call"></param>
+        /// <returns></returns>
+        public T RAW<T>(Func<Telegram.Bot.TelegramBotClient, T> call)
+        {
+            return call(this.Client.TelegramClient);
+        }
+
+        /// <summary>
+        /// This will call a function on the TelegramClient and automatically Retry if an limit has been exceeded.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="call"></param>
+        /// <returns></returns>
+        public async Task<T> API<T>(Func<Telegram.Bot.TelegramBotClient, Task<T>> call)
+        {
+            var numberOfTries = 0;
+            while (numberOfTries < DeviceSession.MaxNumberOfRetries)
+            {
+                try
+                {
+                    return await call(Client.TelegramClient);
+                }
+                catch (ApiRequestException ex)
+                {
+                    if (ex.ErrorCode != 429)
+                        throw;
+
+                    if (ex.Parameters != null)
+                        await Task.Delay(ex.Parameters.RetryAfter * 1000);
+
+                    numberOfTries++;
+                }
+            }
+            return default(T);
+        }
+
+        /// <summary>
+        /// This will call a function on the TelegramClient and automatically Retry if an limit has been exceeded.
+        /// </summary>
+        /// <param name="call"></param>
+        /// <returns></returns>
+        public async Task API(Func<Telegram.Bot.TelegramBotClient, Task> call)
+        {
+            var numberOfTries = 0;
+            while (numberOfTries < DeviceSession.MaxNumberOfRetries)
+            {
+                try
+                {
+                    await call(Client.TelegramClient);
+                    return;
+                }
+                catch (ApiRequestException ex)
+                {
+                    if (ex.ErrorCode != 429)
+                        throw;
+
+                    if (ex.Parameters != null)
+                        await Task.Delay(ex.Parameters.RetryAfter * 1000);
+
+                    numberOfTries++;
+                }
+            }
+        }
+
+
+        #region "Events"
 
         /// <summary>
         /// Eventhandler for sent messages
@@ -741,5 +863,38 @@ namespace TelegramBotBase.Sessions
         {
             (this.__Events[__evMessageReceived] as EventHandler<MessageReceivedEventArgs>)?.Invoke(this, e);
         }
+
+        /// <summary>
+        /// Eventhandler for deleting messages
+        /// </summary>
+        public event EventHandler<MessageDeletedEventArgs> MessageDeleted
+        {
+            add
+            {
+                this.__Events.AddHandler(__evMessageDeleted, value);
+            }
+            remove
+            {
+                this.__Events.RemoveHandler(__evMessageDeleted, value);
+            }
+        }
+
+
+        public void OnMessageDeleted(MessageDeletedEventArgs e)
+        {
+            (this.__Events[__evMessageDeleted] as EventHandler<MessageDeletedEventArgs>)?.Invoke(this, e);
+        }
+
+        #endregion
+
+        #region "Static"
+
+        /// <summary>
+        /// Indicates the maximum number of times a request that received error 
+        /// 429 will be sent again after a timeout until it receives code 200 or an error code not equal to 429.
+        /// </summary>
+        public static uint MaxNumberOfRetries { get; set; }
+
+        #endregion "Static"
     }
 }

TelegramBotBase/States/JSONStateMachine.cs

@@ -5,6 +5,7 @@ using System.Runtime.Serialization.Formatters;
 using System.Text;
 using TelegramBotBase.Args;
 using TelegramBotBase.Base;
+using TelegramBotBase.Form;
 using TelegramBotBase.Interfaces;
 
 namespace TelegramBotBase.States
@@ -18,13 +19,28 @@ namespace TelegramBotBase.States
 
         public bool Overwrite { get; set; }
 
-        public JSONStateMachine(String file, bool overwrite = true)
+        public Type FallbackStateForm { get; private set; }
+
+        /// <summary>
+        /// Will initialize the state machine.
+        /// </summary>
+        /// <param name="file">Path of the file and name where to save the session details.</param>
+        /// <param name="fallbackStateForm">Type of Form which will be saved instead of Form which has <seealso cref="Attributes.IgnoreState"/> attribute declared. Needs to be subclass of <seealso cref="Form.FormBase"/>.</param>
+        /// <param name="overwrite">Declares of the file could be overwritten.</param>
+        public JSONStateMachine(String file, Type fallbackStateForm = null, bool overwrite = true)
         {
             if (file is null)
             {
                 throw new ArgumentNullException(nameof(file));
             }
 
+            this.FallbackStateForm = fallbackStateForm;
+
+            if (this.FallbackStateForm != null && !this.FallbackStateForm.IsSubclassOf(typeof(FormBase)))
+            {
+                throw new ArgumentException("FallbackStateForm is not a subclass of FormBase");
+            }
+
             this.FilePath = file;
             this.Overwrite = overwrite;
         }

TelegramBotBase/States/SimpleJSONStateMachine.cs

@@ -5,6 +5,7 @@ using System.Runtime.Serialization.Formatters;
 using System.Text;
 using TelegramBotBase.Args;
 using TelegramBotBase.Base;
+using TelegramBotBase.Form;
 using TelegramBotBase.Interfaces;
 
 namespace TelegramBotBase.States
@@ -18,13 +19,28 @@ namespace TelegramBotBase.States
 
         public bool Overwrite { get; set; }
 
-        public SimpleJSONStateMachine(String file, bool overwrite = true)
+        public Type FallbackStateForm { get; private set; }
+
+        /// <summary>
+        /// Will initialize the state machine.
+        /// </summary>
+        /// <param name="file">Path of the file and name where to save the session details.</param>
+        /// <param name="fallbackStateForm">Type of Form which will be saved instead of Form which has <seealso cref="Attributes.IgnoreState"/> attribute declared. Needs to be subclass of <seealso cref="Form.FormBase"/>.</param>
+        /// <param name="overwrite">Declares of the file could be overwritten.</param>
+        public SimpleJSONStateMachine(String file, Type fallbackStateForm = null, bool overwrite = true)
         {
             if (file is null)
             {
                 throw new ArgumentNullException(nameof(file));
             }
 
+            this.FallbackStateForm = fallbackStateForm;
+
+            if (this.FallbackStateForm != null && !this.FallbackStateForm.IsSubclassOf(typeof(FormBase)))
+            {
+                throw new ArgumentException("FallbackStateForm is not a subclass of FormBase");
+            }
+
             this.FilePath = file;
             this.Overwrite = overwrite;
         }

TelegramBotBase/States/XMLStateMachine.cs

@@ -7,6 +7,7 @@ using System.Xml;
 using System.Xml.Serialization;
 using TelegramBotBase.Args;
 using TelegramBotBase.Base;
+using TelegramBotBase.Form;
 using TelegramBotBase.Interfaces;
 
 namespace TelegramBotBase.States
@@ -17,13 +18,28 @@ namespace TelegramBotBase.States
 
         public bool Overwrite { get; set; }
 
-        public XMLStateMachine(String file, bool overwrite = true)
+        public Type FallbackStateForm { get; private set; }
+
+        /// <summary>
+        /// Will initialize the state machine.
+        /// </summary>
+        /// <param name="file">Path of the file and name where to save the session details.</param>
+        /// <param name="fallbackStateForm">Type of Form which will be saved instead of Form which has <seealso cref="Attributes.IgnoreState"/> attribute declared. Needs to be subclass of <seealso cref="Form.FormBase"/>.</param>
+        /// <param name="overwrite">Declares of the file could be overwritten.</param>
+        public XMLStateMachine(String file, Type fallbackStateForm = null, bool overwrite = true)
         {
             if (file is null)
             {
                 throw new ArgumentNullException(nameof(file));
             }
 
+            this.FallbackStateForm = fallbackStateForm;
+
+            if (this.FallbackStateForm != null && !this.FallbackStateForm.IsSubclassOf(typeof(FormBase)))
+            {
+                throw new ArgumentException("FallbackStateForm is not a subclass of FormBase");
+            }
+
             this.FilePath = file;
             this.Overwrite = overwrite;
         }

TelegramBotBase/TelegramBotBase.csproj

@@ -1,20 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1;net472;net5;netcoreapp3.1</TargetFrameworks>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
-    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <PackageProjectUrl>https://github.com/MajMcCloud/TelegramBotFramework</PackageProjectUrl>
     <RepositoryUrl>https://github.com/MajMcCloud/TelegramBotFramework</RepositoryUrl>
-    <PackageReleaseNotes>- moving from .Net Framework 4.7.2 to  .Net Standard 2.1 for the Library and .Net Core 3.0 for the test project!</PackageReleaseNotes>
+    <PackageReleaseNotes>- moving from .Net Framework 4.7.2 to .Net Standard 2.1 for the Library and .Net Core 3.1 for the test project!</PackageReleaseNotes>
     <Configurations>Debug;Release;</Configurations>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <RunAnalyzersDuringBuild>false</RunAnalyzersDuringBuild>
     <RunAnalyzersDuringLiveAnalysis>false</RunAnalyzersDuringLiveAnalysis>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+  </ItemGroup>
+
+
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
@@ -54,23 +62,16 @@
     <None Remove="Archive\**" />
   </ItemGroup>
 
-  <ItemGroup>
-    <None Remove="cpack.ps1" />
-    <None Remove="cpush.ps1" />
-    <None Remove="nuget.exe" />
-    <None Remove="TelegramBotBase.1.5.0.nupkg" />
-    <None Remove="TelegramBotBase.1.5.0.zip" />
-    <None Remove="TelegramBotBase.1.5.1.nupkg" />
-    <None Remove="TelegramBotBase.1.5.1.zip" />
-    <None Remove="TelegramBotBase.1.5.2.nupkg" />
-    <None Remove="TelegramBotBase.1.5.2.zip" />
-    <None Remove="TelegramBotBase.nuspec" />
-  </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="System.Drawing.Common" Version="4.7.0" />
+    <PackageReference Include="System.ComponentModel" Version="4.3.0" />
-    <PackageReference Include="Telegram.Bot" Version="15.5.1" />
+    <PackageReference Include="System.Drawing.Common" Version="5.0.2" />
+    <PackageReference Include="Telegram.Bot" Version="16.0.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Controls\Reply\" />
   </ItemGroup>
 
 </Project>

TelegramBotBase/Tools/Console.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace TelegramBotBase.Tools
+{
+    public static class Console
+    {
+        [DllImport("Kernel32")]
+        private static extern bool SetConsoleCtrlHandler(EventHandler handler, bool add);
+
+        private delegate bool EventHandler(CtrlType sig);
+        static EventHandler _handler;
+
+        static List<Action> Actions = new List<Action>();
+
+        enum CtrlType
+        {
+            CTRL_C_EVENT = 0,
+            CTRL_BREAK_EVENT = 1,
+            CTRL_CLOSE_EVENT = 2,
+            CTRL_LOGOFF_EVENT = 5,
+            CTRL_SHUTDOWN_EVENT = 6
+        }
+
+        static Console()
+        {
+
+        }
+
+        public static void SetHandler(Action action)
+        {
+            Actions.Add(action);
+
+            if (_handler != null)
+                return;
+
+            _handler += new EventHandler(Handler);
+            SetConsoleCtrlHandler(_handler, true);
+        }
+
+        private static bool Handler(CtrlType sig)
+        {
+            switch (sig)
+            {
+                case CtrlType.CTRL_C_EVENT:
+                case CtrlType.CTRL_LOGOFF_EVENT:
+                case CtrlType.CTRL_SHUTDOWN_EVENT:
+                case CtrlType.CTRL_CLOSE_EVENT:
+
+                    foreach (var a in Actions)
+                    {
+                        a();
+                    }
+
+                    return false;
+
+                default:
+                    return false;
+            }
+        }
+
+    }
+}

TelegramBotBase/Tools/Conversion.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Tools
+{
+    public static class Conversion
+    {
+        public static void CustomConversionChecks(FormBase form, KeyValuePair<string, object> p, System.Reflection.PropertyInfo f)
+        {
+            //Newtonsoft Int64/Int32 converter issue
+            if (f.PropertyType == typeof(Int32))
+            {
+                int i = 0;
+                if (int.TryParse(p.Value.ToString(), out i))
+                {
+                    f.SetValue(form, i);
+                }
+                return;
+            }
+
+            //Newtonsoft Double/Decimal converter issue
+            if (f.PropertyType == typeof(Decimal) | f.PropertyType == typeof(Nullable<Decimal>))
+            {
+                decimal d = 0;
+                if (decimal.TryParse(p.Value.ToString(), out d))
+                {
+                    f.SetValue(form, d);
+                }
+                return;
+            }
+
+
+        }
+
+    }
+}

TelegramBotBase/Tools/Time.cs

@@ -8,6 +8,21 @@ namespace TelegramBotBase.Tools
 {
     public static class Time
     {
+        public static bool TryParseDay(string src, DateTime currentDate, out int resultDay)
+        {
+            return int.TryParse(src, out resultDay) && resultDay >= 1 && resultDay <= DateTime.DaysInMonth(currentDate.Year, currentDate.Month);
+        }
+
+        public static bool TryParseMonth(string src, out int resultMonth)
+        {
+            return int.TryParse(src, out resultMonth) && resultMonth >= 1 && resultMonth <= 12;
+        }
+
+        public static bool TryParseYear(string src, out int resultYear)
+        {
+            return int.TryParse(src, out resultYear) && resultYear >= 0 && resultYear <= DateTime.MaxValue.Year;
+        }
+        
         public static DateTime StartOfWeek(this DateTime dt, DayOfWeek startOfWeek)
         {
             int diff = dt.DayOfWeek - startOfWeek;

TelegramBotBaseTest/Program.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Telegram.Bot.Types;
+using TelegramBotBase;
+using TelegramBotBase.Form;
+using TelegramBotBaseTest.Tests;
+using TelegramBotBase.Commands;
+namespace TelegramBotBaseTest
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+
+            BotBase<Start> bb = new BotBase<Start>(APIKey);
+
+            bb.BotCommands.AddStartCommand("Starts the bot");
+            bb.BotCommands.AddHelpCommand("Should show you some help");
+            bb.BotCommands.AddSettingsCommand("Should show you some settings");
+            bb.BotCommands.Add(new BotCommand() { Command = "form1", Description = "Opens test form 1" });
+            bb.BotCommands.Add(new BotCommand() { Command = "form2", Description = "Opens test form 2" });
+            bb.BotCommands.Add(new BotCommand() { Command = "params", Description = "Returns all send parameters as a message." });
+
+            bb.BotCommand += async (s, en) =>
+            {
+                switch (en.Command)
+                {
+                    case "/start":
+
+                        var start = new Menu();
+
+                        await en.Device.ActiveForm.NavigateTo(start);
+
+                        break;
+                    case "/form1":
+
+                        var form1 = new TestForm();
+
+                        await en.Device.ActiveForm.NavigateTo(form1);
+
+                        break;
+
+                    case "/form2":
+
+                        var form2 = new TestForm2();
+
+                        await en.Device.ActiveForm.NavigateTo(form2);
+
+                        break;
+
+                    case "/params":
+
+                        String m = en.Parameters.DefaultIfEmpty("").Aggregate((a, b) => a + " and " + b);
+                        
+                        await en.Device.Send("Your parameters are: " + m, replyTo: en.Device.LastMessageId);
+
+                        en.Handled = true;
+
+                        break;
+                }
+
+            };
+
+            //Update Bot commands to botfather
+            bb.UploadBotCommands().Wait();
+
+            bb.SetSetting(TelegramBotBase.Enums.eSettings.LogAllMessages, true);
+
+            bb.Message += (s,en) =>
+            {
+                Console.WriteLine(en.DeviceId + " " + en.Message.MessageText + " " + (en.Message.RawData ?? ""));
+            };
+
+            bb.Start();
+
+
+
+            Console.WriteLine("Telegram Bot started...");
+
+            Console.WriteLine("Press q to quit application.");
+
+
+            Console.ReadLine();
+
+            bb.Stop();
+
+        }
+
+
+    }
+}

TelegramBotBaseTest/TelegramBotBaseTest.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFrameworks>netcoreapp3.0;net461</TargetFrameworks>
+    <TargetFrameworks>netcoreapp3.1;net5</TargetFrameworks>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <Configurations>Debug;Release</Configurations>
   </PropertyGroup>

TelegramBotBaseTest/Tests/Controls/ButtonGridForm.cs

@@ -5,6 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Args;
 using TelegramBotBase.Controls;
+using TelegramBotBase.Controls.Hybrid;
 using TelegramBotBase.Form;
 
 namespace TelegramBotBaseTest.Tests.Controls
@@ -44,7 +45,7 @@ namespace TelegramBotBaseTest.Tests.Controls
 
         }
 
-        private async void Bg_ButtonClicked(object sender, ButtonClickedEventArgs e)
+        private async Task Bg_ButtonClicked(object sender, ButtonClickedEventArgs e)
         {
             if (e.Button == null)
                 return;

TelegramBotBaseTest/Tests/Controls/ButtonGridPagingForm.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Args;
+using TelegramBotBase.Controls;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Controls
+{
+    public class ButtonGridPagingForm : AutoCleanForm
+    {
+
+        ButtonGrid m_Buttons = null;
+
+        public ButtonGridPagingForm()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+
+            this.Init += ButtonGridForm_Init;
+        }
+
+        private async Task ButtonGridForm_Init(object sender, InitEventArgs e)
+        {
+            m_Buttons = new ButtonGrid();
+
+            m_Buttons.KeyboardType = TelegramBotBase.Enums.eKeyboardType.ReplyKeyboard;
+
+            m_Buttons.EnablePaging = true;
+            m_Buttons.EnableSearch = true;
+
+            m_Buttons.HeadLayoutButtonRow = new List<ButtonBase>() { new ButtonBase("Back", "back") };
+
+            var countries = CultureInfo.GetCultures(CultureTypes.SpecificCultures);
+
+            ButtonForm bf = new ButtonForm();
+
+            foreach (var c in countries)
+            {
+                bf.AddButtonRow(new ButtonBase(c.EnglishName, c.EnglishName));
+            }
+
+            m_Buttons.ButtonsForm = bf;
+
+            m_Buttons.ButtonClicked += Bg_ButtonClicked;
+
+            this.AddControl(m_Buttons);
+
+
+        }
+
+        private async Task Bg_ButtonClicked(object sender, ButtonClickedEventArgs e)
+        {
+            if (e.Button == null)
+                return;
+
+            if (e.Button.Value == "back")
+            {
+                var start = new Menu();
+                await this.NavigateTo(start);
+            }
+            else
+            {
+
+                await this.Device.Send($"Button clicked with Text: {e.Button.Text} and Value {e.Button.Value}");
+            }
+
+
+        }
+    }
+}

TelegramBotBaseTest/Tests/Controls/ButtonGridTagForm.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Args;
+using TelegramBotBase.Controls;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Controls
+{
+    public class ButtonGridTagForm : AutoCleanForm
+    {
+
+        TaggedButtonGrid m_Buttons = null;
+
+        public ButtonGridTagForm()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+
+            this.Init += ButtonGridTagForm_Init;
+        }
+
+        private async Task ButtonGridTagForm_Init(object sender, InitEventArgs e)
+        {
+            m_Buttons = new TaggedButtonGrid();
+
+            m_Buttons.KeyboardType = TelegramBotBase.Enums.eKeyboardType.ReplyKeyboard;
+
+            m_Buttons.EnablePaging = true;
+
+            m_Buttons.HeadLayoutButtonRow = new List<ButtonBase>() { new ButtonBase("Back", "back") };
+            
+
+            var countries = CultureInfo.GetCultures(CultureTypes.SpecificCultures);
+
+            ButtonForm bf = new ButtonForm();
+
+            foreach (var c in countries)
+            {
+                bf.AddButtonRow(new TagButtonBase(c.EnglishName, c.EnglishName, c.Parent.EnglishName));
+            }
+
+            m_Buttons.Tags = countries.Select(a => a.Parent.EnglishName).Distinct().OrderBy(a => a).ToList();
+            m_Buttons.SelectedTags = countries.Select(a => a.Parent.EnglishName).Distinct().OrderBy(a => a).ToList();
+
+            m_Buttons.EnableCheckAllTools = true;
+
+            m_Buttons.DataSource = new TelegramBotBase.Datasources.ButtonFormDataSource(bf);
+
+            m_Buttons.ButtonClicked += Bg_ButtonClicked;
+
+            this.AddControl(m_Buttons);
+        }
+
+        private async Task Bg_ButtonClicked(object sender, ButtonClickedEventArgs e)
+        {
+            if (e.Button == null)
+                return;
+
+            switch (e.Button.Value)
+            {
+
+                case "back":
+                    var start = new Menu();
+                    await this.NavigateTo(start);
+                    return;
+
+            }
+
+
+            await this.Device.Send($"Button clicked with Text: {e.Button.Text} and Value {e.Button.Value}");
+        }
+    }
+}

TelegramBotBaseTest/Tests/Controls/CalendarPickerForm.cs

@@ -8,6 +8,7 @@ using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 using TelegramBotBase.Controls;
 using TelegramBotBase.Args;
+using TelegramBotBase.Controls.Inline;
 
 namespace TelegramBotBaseTest.Tests.Controls
 {

TelegramBotBaseTest/Tests/Controls/CheckedButtonListForm.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Args;
+using TelegramBotBase.Controls;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Controls
+{
+    public class CheckedButtonListForm : AutoCleanForm
+    {
+
+        CheckedButtonList m_Buttons = null;
+
+        public CheckedButtonListForm()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+
+            this.Init += CheckedButtonListForm_Init;
+        }
+
+        private async Task CheckedButtonListForm_Init(object sender, InitEventArgs e)
+        {
+            m_Buttons = new CheckedButtonList();
+
+            m_Buttons.KeyboardType = TelegramBotBase.Enums.eKeyboardType.InlineKeyBoard;
+            m_Buttons.EnablePaging = true;
+
+            m_Buttons.HeadLayoutButtonRow = new List<ButtonBase>() { new ButtonBase("Back", "back"), new ButtonBase("Switch Keyboard", "switch") };
+
+            m_Buttons.SubHeadLayoutButtonRow = new List<ButtonBase>() { new ButtonBase("No checked items", "$") };
+
+            ButtonForm bf = new ButtonForm();
+
+            for (int i = 0; i < 30; i++)
+            {
+                bf.AddButtonRow($"{i + 1}. Item", i.ToString());
+            }
+
+            m_Buttons.DataSource = new TelegramBotBase.Datasources.ButtonFormDataSource(bf);
+
+            m_Buttons.ButtonClicked += Bg_ButtonClicked;
+            m_Buttons.CheckedChanged += M_Buttons_CheckedChanged;
+
+            this.AddControl(m_Buttons);
+        }
+
+        private async Task M_Buttons_CheckedChanged(object sender, CheckedChangedEventArgs e)
+        {
+            m_Buttons.SubHeadLayoutButtonRow = new List<ButtonBase>() { new ButtonBase($"{m_Buttons.CheckedItems.Count} checked items", "$") };
+        }
+
+        private async Task Bg_ButtonClicked(object sender, ButtonClickedEventArgs e)
+        {
+            if (e.Button == null)
+                return;
+
+            switch (e.Button.Value)
+            {
+                case "back":
+
+                    var start = new Menu();
+                    await NavigateTo(start);
+                    break;
+
+
+                case "switch":
+                    switch (m_Buttons.KeyboardType)
+                    {
+                        case TelegramBotBase.Enums.eKeyboardType.ReplyKeyboard:
+                            m_Buttons.KeyboardType = TelegramBotBase.Enums.eKeyboardType.InlineKeyBoard;
+                            break;
+                        case TelegramBotBase.Enums.eKeyboardType.InlineKeyBoard:
+                            m_Buttons.KeyboardType = TelegramBotBase.Enums.eKeyboardType.ReplyKeyboard;
+                            break;
+                    }
+
+
+                    break;
+
+                default:
+                    await Device.Send($"Button clicked with Text: {e.Button.Text} and Value {e.Button.Value}");
+                    break;
+            }
+
+
+        }
+    }
+}

TelegramBotBaseTest/Tests/Controls/MonthPickerForm.cs

@@ -8,6 +8,7 @@ using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 using TelegramBotBase.Controls;
 using TelegramBotBase.Args;
+using TelegramBotBase.Controls.Inline;
 
 namespace TelegramBotBaseTest.Tests.Controls
 {

TelegramBotBaseTest/Tests/Controls/MultiToggleButtons.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Args;
+using TelegramBotBase.Controls;
+using TelegramBotBase.Controls.Inline;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Controls
+{
+    public class MultiToggleButtons : AutoCleanForm
+    {
+        public MultiToggleButtons()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+
+            this.Init += ToggleButtons_Init;
+        }
+
+        private async Task ToggleButtons_Init(object sender, InitEventArgs e)
+        {
+
+            var mtb = new MultiToggleButton();
+
+            mtb.Options = new List<ButtonBase>() { new ButtonBase("Option 1", "1"), new ButtonBase("Option 2", "2"), new ButtonBase("Option 3", "3") };
+            mtb.SelectedOption = mtb.Options.FirstOrDefault();
+            mtb.Toggled += Tb_Toggled;
+            this.AddControl(mtb);
+
+            mtb = new MultiToggleButton();
+
+            mtb.Options = new List<ButtonBase>() { new ButtonBase("Option 4", "4"), new ButtonBase("Option 5", "5"), new ButtonBase("Option 6", "6") };
+            mtb.SelectedOption = mtb.Options.FirstOrDefault();
+            mtb.AllowEmptySelection = false;
+            mtb.Toggled += Tb_Toggled;
+            this.AddControl(mtb);
+        }
+
+        private void Tb_Toggled(object sender, EventArgs e)
+        {
+            var tb = sender as MultiToggleButton;
+            if (tb.SelectedOption != null)
+            {
+                Console.WriteLine(tb.ID.ToString() + " was pressed, and toggled to " + tb.SelectedOption.Value);
+                return;
+            }
+
+            Console.WriteLine("Selection for " + tb.ID.ToString() + " has been removed.");
+        }
+    }
+}

TelegramBotBaseTest/Tests/Controls/MultiViewForm.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Controls
+{
+    public class MultiViewForm : AutoCleanForm
+    {
+
+        Subclass.MultiViewTest mvt = null;
+
+        ButtonGrid bg = null;
+
+        public MultiViewForm()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+            this.Init += MultiViewForm_Init;
+        }
+
+        private async Task MultiViewForm_Init(object sender, TelegramBotBase.Args.InitEventArgs e)
+        {
+            mvt = new Subclass.MultiViewTest();
+
+            AddControl(mvt);
+
+            bg = new ButtonGrid();
+            bg.ButtonsForm = new ButtonForm();
+            bg.ButtonsForm.AddButtonRow("Back", "$back$");
+            bg.ButtonClicked += Bg_ButtonClicked;
+            bg.KeyboardType = TelegramBotBase.Enums.eKeyboardType.ReplyKeyboard;
+            AddControl(bg);
+        }
+
+        private async Task Bg_ButtonClicked(object sender, TelegramBotBase.Args.ButtonClickedEventArgs e)
+        {
+            switch(e.Button.Value)
+            {
+                case "$back$":
+
+                    var mn = new Menu();
+                    await NavigateTo(mn);
+
+                    break;
+            }
+        }
+
+        public override async Task Load(MessageResult message)
+        {
+            
+
+
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            
+
+        }
+
+
+        public override async Task Render(MessageResult message)
+        {
+            
+        }
+
+
+
+    }
+}

TelegramBotBaseTest/Tests/Controls/Subclass/MultiViewTest.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Args;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Controls.Subclass
+{
+    public class MultiViewTest : TelegramBotBase.Controls.Hybrid.MultiView
+    {
+
+
+        public override async Task Action(MessageResult result, string value = null)
+        {
+
+            switch (result.RawData)
+            {
+                case "back":
+
+                    this.SelectedViewIndex--;
+
+                    break;
+                case "next":
+
+                    this.SelectedViewIndex++;
+
+                    break;
+            }
+
+        }
+
+        public override async Task RenderView(RenderViewEventArgs e)
+        {
+
+            ButtonForm bf = new ButtonForm();
+            bf.AddButtonRow(new ButtonBase("Back", "back"), new ButtonBase("Next", "next"));
+
+            switch (e.CurrentView)
+            {
+                case 0:
+                case 1:
+                case 2:
+
+                    await Device.Send($"Page {e.CurrentView + 1}", bf);
+
+                    break;
+
+                default:
+
+                    await Device.Send("Unknown Page", bf);
+
+                    break;
+
+
+            }
+
+        }
+
+
+
+    }
+}

TelegramBotBaseTest/Tests/Controls/ToggleButtons.cs

@@ -5,6 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Args;
 using TelegramBotBase.Controls;
+using TelegramBotBase.Controls.Inline;
 using TelegramBotBase.Form;
 
 namespace TelegramBotBaseTest.Tests.Controls

TelegramBotBaseTest/Tests/Controls/TreeViewForms.cs

@@ -7,6 +7,7 @@ using TelegramBotBase.Form;
 using TelegramBotBase.Controls;
 using TelegramBotBase.Base;
 using TelegramBotBase.Args;
+using TelegramBotBase.Controls.Inline;
 
 namespace TelegramBotBaseTest.Tests.Controls
 {

TelegramBotBaseTest/Tests/Datasources/CustomDataSource.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Datasources;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Datasources
+{
+    public class CustomDataSource : ButtonFormDataSource
+    {
+
+        public List<String> Countries = new List<string>() { "Country 1", "Country 2", "Country 3" };
+
+        public CustomDataSource()
+        {
+            loadData();
+        }
+
+        /// <summary>
+        /// This method has the example purpose of creating and loading some example data.
+        /// When using a database you do not need this kind of method.
+        /// </summary>
+        private void loadData()
+        {
+            //Exists data source? Read it
+            if (File.Exists(AppContext.BaseDirectory + "countries.json"))
+            {
+                try
+                {
+                    var List = Newtonsoft.Json.JsonConvert.DeserializeObject<List<String>>(File.ReadAllText("countries.json"));
+
+
+                    Countries = List;
+                }
+                catch
+                {
+
+                }
+
+
+                return;
+            }
+
+            //If not, create it
+            try
+            {
+                var countries = CultureInfo.GetCultures(CultureTypes.SpecificCultures).Select(a => a.DisplayName).ToList();
+
+                Countries = countries;
+
+                var tmp = Newtonsoft.Json.JsonConvert.SerializeObject(countries);
+
+                File.WriteAllText( AppContext.BaseDirectory + "countries.json", tmp);
+            }
+            catch
+            {
+
+            }
+
+        }
+
+        public override ButtonRow ItemAt(int index)
+        {
+            var item = Countries.ElementAt(index);
+            if (item == null)
+                return new ButtonRow();
+
+            return Render(item);
+        }
+
+        public override List<ButtonRow> ItemRange(int start, int count)
+        {
+            var items = Countries.Skip(start).Take(count);
+
+            List<ButtonRow> lst = new List<ButtonRow>();
+            foreach (var c in items)
+            {
+                lst.Add(Render(c));
+            }
+
+            return lst;
+        }
+
+        public override List<ButtonRow> AllItems()
+        {
+            List<ButtonRow> lst = new List<ButtonRow>();
+            foreach (var c in Countries)
+            {
+                lst.Add(Render(c));
+            }
+            return lst;
+        }
+
+        public override ButtonForm PickItems(int start, int count, string filter = null)
+        {
+            List<ButtonRow> rows = ItemRange(start, count);
+
+            ButtonForm lst = new ButtonForm();
+            foreach (var c in rows)
+            {
+                lst.AddButtonRow(c);
+            }
+            return lst;
+        }
+
+        public override ButtonForm PickAllItems(string filter = null)
+        {
+            List<ButtonRow> rows = AllItems();
+
+            ButtonForm bf = new ButtonForm();
+
+            bf.AddButtonRows(rows);
+
+            return bf;
+        }
+
+        public override int CalculateMax(string filter = null)
+        {
+            if (filter == null)
+                return Countries.Count;
+
+            return Countries.Where(a => a.IndexOf(filter, StringComparison.InvariantCultureIgnoreCase) != -1).Count();
+        }
+
+        public override ButtonRow Render(object data)
+        {
+            var s = data as String;
+            if (s == null)
+                return new ButtonRow(new ButtonBase("Empty", "zero"));
+
+            return new ButtonRow(new ButtonBase(s, s));
+        }
+
+        public override int Count
+        {
+            get
+            {
+                return Countries.Count;
+            }
+        }
+
+        public override int ColumnCount
+        {
+            get
+            {
+                return 1;
+            }
+        }
+
+        public override int RowCount
+        {
+            get
+            {
+                return this.Count;
+            }
+        }
+
+    }
+}

TelegramBotBaseTest/Tests/Datasources/List.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Datasources
+{
+    public class List : FormBase
+    {
+        ButtonGrid __buttons = null;
+
+        public List()
+        {
+            this.Init += List_Init;
+        }
+
+        private async Task List_Init(object sender, TelegramBotBase.Args.InitEventArgs e)
+        {
+
+            __buttons = new ButtonGrid();
+
+            __buttons.EnablePaging = true;
+            __buttons.EnableSearch = false;
+            __buttons.ButtonClicked += __buttons_ButtonClicked;
+            __buttons.KeyboardType = TelegramBotBase.Enums.eKeyboardType.ReplyKeyboard;
+            __buttons.DeleteReplyMessage = true;
+
+            __buttons.HeadLayoutButtonRow = new ButtonRow(new ButtonBase("Back", "back"));
+
+            var cds = new CustomDataSource();
+            __buttons.DataSource = cds;
+
+            AddControl(__buttons);
+        }
+
+        private async Task __buttons_ButtonClicked(object sender, TelegramBotBase.Args.ButtonClickedEventArgs e)
+        {
+            switch(e.Button.Value)
+            {
+                case "back":
+
+                    var mn = new Menu();
+                    await NavigateTo(mn);
+
+                    break;
+            }
+        }
+
+        public override async Task Load(MessageResult message)
+        {
+            
+        }
+
+
+        public override async Task Render(MessageResult message)
+        {
+            
+        }
+
+
+    }
+}

TelegramBotBaseTest/Tests/Groups/LinkReplaceTest.cs

@@ -12,7 +12,7 @@ namespace TelegramBotBaseTest.Tests.Groups
     public class LinkReplaceTest : TelegramBotBase.Form.GroupForm
     {
 
-        Dictionary<int, int> Counter { get; set; } = new Dictionary<int, int>();
+        Dictionary<long, int> Counter { get; set; } = new Dictionary<long, int>();
 
         private const int Maximum = 3;
 

TelegramBotBaseTest/Tests/Menu.cs

@@ -5,6 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
+using TelegramBotBaseTest.Tests.Controls;
 
 namespace TelegramBotBaseTest.Tests
 {
@@ -27,6 +28,7 @@ namespace TelegramBotBaseTest.Tests
             }
 
 
+            await Device.HideReplyKeyboard();
         }
 
         public override async Task Action(MessageResult message)
@@ -39,7 +41,9 @@ namespace TelegramBotBaseTest.Tests
             if (call == null)
                 return;
 
-            switch(call.Value)
+            message.Handled = true;
+
+            switch (call.Value)
             {
                 case "text":
 
@@ -91,8 +95,6 @@ namespace TelegramBotBaseTest.Tests
 
                 case "data":
 
-                    message.Handled = true;
-
                     var data = new DataForm();
 
                     await this.NavigateTo(data);
@@ -101,8 +103,6 @@ namespace TelegramBotBaseTest.Tests
 
                 case "calendar":
 
-                    message.Handled = true;
-
                     var calendar = new Controls.CalendarPickerForm();
 
                     await this.NavigateTo(calendar);
@@ -111,8 +111,6 @@ namespace TelegramBotBaseTest.Tests
 
                 case "month":
 
-                    message.Handled = true;
-
                     var month = new Controls.MonthPickerForm();
 
                     await this.NavigateTo(month);
@@ -121,8 +119,6 @@ namespace TelegramBotBaseTest.Tests
 
                 case "treeview":
 
-                    message.Handled = true;
-
                     var tree = new Controls.TreeViewForms();
 
                     await this.NavigateTo(tree);
@@ -131,21 +127,90 @@ namespace TelegramBotBaseTest.Tests
 
                 case "togglebuttons":
 
-                    message.Handled = true;
-
                     var tb = new Controls.ToggleButtons();
 
                     await this.NavigateTo(tb);
 
                     break;
-                case "buttongrid":
 
-                    message.Handled = true;
+                case "multitogglebuttons":
+
+                    var mtb = new Controls.MultiToggleButtons();
+
+                    await this.NavigateTo(mtb);
+
+                    break;
+
+                case "buttongrid":
 
                     var bg = new Controls.ButtonGridForm();
 
                     await this.NavigateTo(bg);
 
+                    break;
+
+                case "buttongridfilter":
+
+                    var bg2 = new Controls.ButtonGridPagingForm();
+
+                    await this.NavigateTo(bg2);
+
+                    break;
+
+                case "buttongridtags":
+
+                    var bg3 = new Controls.ButtonGridTagForm();
+
+                    await this.NavigateTo(bg3);
+
+                    break;
+
+                case "multiview":
+
+                    var mvf = new MultiViewForm();
+
+                    await NavigateTo(mvf);
+
+
+                    break;
+
+                case "checkedbuttonlist":
+
+                    var cbl = new CheckedButtonListForm();
+
+                    await NavigateTo(cbl);
+
+
+                    break;
+
+                case "navigationcontroller":
+
+                    var nc = new Navigation.Start();
+
+                    await NavigateTo(nc);
+
+
+                    break;
+
+                case "dynamicbuttongrid":
+
+                    var dg = new Datasources.List();
+
+                    await NavigateTo(dg);
+
+                    break;
+
+                case "notifications":
+
+                    var not = new Notifications.Start();
+                    await NavigateTo(not);
+
+                    break;
+
+                default:
+
+                    message.Handled = false;
+
                     break;
             }
 
@@ -173,8 +238,24 @@ namespace TelegramBotBaseTest.Tests
 
             btn.AddButtonRow(new ButtonBase("#11 ToggleButtons", new CallbackData("a", "togglebuttons").Serialize()));
 
+            btn.AddButtonRow(new ButtonBase("#11.2 MultiToggleButtons", new CallbackData("a", "multitogglebuttons").Serialize()));
+
             btn.AddButtonRow(new ButtonBase("#12 ButtonGrid", new CallbackData("a", "buttongrid").Serialize()));
 
+            btn.AddButtonRow(new ButtonBase("#13 ButtonGrid Paging & Filter", new CallbackData("a", "buttongridfilter").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#14 ButtonGrid Tags (Filter)", new CallbackData("a", "buttongridtags").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#15 MultiView", new CallbackData("a", "multiview").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#16 CheckedButtonList", new CallbackData("a", "checkedbuttonlist").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#17 NavigationController (Push/Pop)", new CallbackData("a", "navigationcontroller").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#18 Dynamic ButtonGrid (DataSources)", new CallbackData("a", "dynamicbuttongrid").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#19 Notifications", new CallbackData("a", "notifications").Serialize()));
+
             await this.Device.Send("Choose your test:", btn);
         }
 

TelegramBotBaseTest/Tests/Navigation/CustomController.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Form;
+using TelegramBotBase.Form.Navigation;
+
+namespace TelegramBotBaseTest.Tests.Navigation
+{
+    class CustomController : NavigationController
+    {
+        public CustomController(FormBase form) : base(form)
+        {
+
+        }
+
+
+        public override Task PushAsync(FormBase form, params object[] args)
+        {
+            Console.WriteLine($"Pushes form (Count on stack {this.Index + 1})");
+            //Device.Send($"Pushes form (Count on stack {this.Index + 1})");
+
+            return base.PushAsync(form, args);
+        }
+
+
+        public override Task PopAsync()
+        {
+            Console.WriteLine($"Pops one form (Count on stack {this.Index + 1})");
+            //Device.Send($"Pops one form (Count on stack {this.Index + 1})");
+
+            return base.PopAsync();
+        }
+
+        public override Task PopToRootAsync()
+        {
+            Console.WriteLine($"Moved back to root (Count on stack {this.Index + 1})");
+            //Device.Send($"Moved back to root (Count on stack {this.Index + 1})");
+
+            return base.PopToRootAsync();
+        }
+
+    }
+}

TelegramBotBaseTest/Tests/Navigation/Form1.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Telegram.Bot.Types;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Navigation
+{
+    public class Form1 : FormBase
+    {
+        Message msg = null;
+
+        public Form1()
+        {
+            this.Closed += Form1_Closed;
+        }
+
+        private async Task Form1_Closed(object sender, EventArgs e)
+        {
+            if (msg == null)
+                return;
+
+            await Device.DeleteMessage(msg);
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.Handled)
+                return;
+
+            await message.ConfirmAction();
+
+            switch (message.RawData)
+            {
+                case "next":
+
+                    message.Handled = true;
+
+                    var f1 = new Form1();
+
+                    await NavigationController.PushAsync(f1);
+
+
+                    break;
+
+                case "previous":
+
+                    message.Handled = true;
+
+                    //Pop's the current form and move the previous one. The root form will be the Start class.
+                    await NavigationController.PopAsync();
+
+                    break;
+
+                case "root":
+
+                    message.Handled = true;
+
+                    await NavigationController.PopToRootAsync();
+
+                    break;
+
+
+            }
+
+
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            if (msg != null)
+                return;
+
+            var bf = new ButtonForm();
+            bf.AddButtonRow("Next page", "next");
+            bf.AddButtonRow("Previous page", "previous");
+            bf.AddButtonRow("Back to root", "root");
+
+            msg = await Device.Send($"Choose your options (Count on stack {NavigationController.Index + 1})", bf);
+
+        }
+
+
+    }
+}

TelegramBotBaseTest/Tests/Navigation/Start.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Telegram.Bot.Types;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+using TelegramBotBase.Form.Navigation;
+
+namespace TelegramBotBaseTest.Tests.Navigation
+{
+    public class Start : FormBase
+    {
+
+        Message msg = null;
+
+        public Start()
+        {
+            this.Closed += Start_Closed;
+        }
+
+        private async Task Start_Closed(object sender, EventArgs e)
+        {
+            if (msg == null)
+                return;
+
+            await Device.DeleteMessage(msg);
+        }
+
+        public override async Task Load(MessageResult message)
+        {
+
+
+
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.Handled)
+                return;
+
+            await message.ConfirmAction();
+
+            switch (message.RawData)
+            {
+                case "yes":
+
+                    message.Handled = true;
+
+                    //Create navigation controller and navigate to it, keep the current form as root form so we can get back to here later
+                    var nc = new CustomController(this);
+
+                    var f1 = new Form1();
+
+                    await NavigateTo(nc);
+
+                    await nc.PushAsync(f1);
+
+
+                    break;
+                case "no":
+
+                    message.Handled = true;
+
+                    var mn = new Menu();
+
+                    await NavigateTo(mn);
+
+
+                    break;
+            }
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            var bf = new ButtonForm();
+
+            bf.AddButtonRow("Yes", "yes");
+            bf.AddButtonRow("No", "no");
+
+            msg = await Device.Send("Open controller?", bf);
+
+
+        }
+
+    }
+}