Update README.md

New version v5

.github/FUNDING.yml

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

.gitignore

@@ -240,3 +240,15 @@ ModelManifest.xml
 
 # FAKE - F# Make
 .fake/
+MigrationBackup
+TelegramBotBase/nuget.exe
+Material
+TelegramBotBase/cp.ps1
+TelegramBotBase/TelegramBotBase.nuspec
+Program.cs
+TelegramBotBase/Archive
+/TelegramBotBase/TelegramBotBase.1.5.0.zip
+/TelegramBotBase/TelegramBotBase.1.5.1.zip
+/TelegramBotBase/TelegramBotBase.1.5.2.zip
+/TelegramBotBase/cpush.ps1
+/TelegramBotBase/cpack.ps1

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

@@ -1,17 +1,17 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<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>{5817184C-0D59-4924-AC6C-6B943967811C}</ProjectGuid>
+    <ProjectGuid>{673A56F5-6110-4AED-A68D-562FD6ED3EA6}</ProjectGuid>
     <OutputType>Exe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>TelegramBaseTest</RootNamespace>
-    <AssemblyName>TelegramBaseTest</AssemblyName>
-    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <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>
@@ -33,61 +33,37 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.12.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <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.Drawing" />
     <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=14.10.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\Telegram.Bot.14.10.0\lib\net45\Telegram.Bot.dll</HintPath>
+    <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" />
-    <Compile Include="Tests\ButtonTestForm.cs" />
-    <Compile Include="Tests\DataForm.cs" />
-    <Compile Include="Tests\ProgressTest.cs" />
-    <Compile Include="Tests\Register\PerForm.cs" />
-    <Compile Include="Tests\Register\PerStep.cs" />
-    <Compile Include="Tests\Register\Start.cs" />
-    <Compile Include="Tests\Register\Steps\Data.cs" />
-    <Compile Include="Tests\Register\Steps\Step3.cs" />
-    <Compile Include="Tests\Register\Steps\Step2.cs" />
-    <Compile Include="Tests\Register\Steps\Step1.cs" />
-    <Compile Include="Tests\SimpleForm.cs" />
-    <Compile Include="Tests\Start.cs" />
-    <Compile Include="Tests\TestForm.cs" />
-    <Compile Include="Tests\TestForm2.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="App.config">
-      <SubType>Designer</SubType>
-    </None>
-    <None Include="packages.config">
-      <SubType>Designer</SubType>
-    </None>
+    <None Include="App.config" />
+    <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\TelegramBotBase\TelegramBotBase.csproj">
-      <Project>{a61eda27-cfdf-4bcb-b2d6-184f94904f2d}</Project>
+    <ProjectReference Include="..\..\TelegramBotBase\TelegramBotBase.csproj">
+      <Project>{0bd16fb9-7ed4-4ccb-83eb-5cee538e1b6c}</Project>
       <Name>TelegramBotBase</Name>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
 </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

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

Examples/SystemCommandsBot/commands/Commando.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace SystemCommandsBot.commands
+{
+    public class Commando
+    {
+        public int ID { get; set; }
+
+        public String Title { get; set; }
+
+        public String ShellCmd { get; set; }
+
+        public bool Enabled { get; set; } = true;
+
+        public String Action { get; set; }
+
+        public bool UseShell { get; set; } = true;
+
+
+        public int? MaxInstances { get; set; }
+
+        public String ProcName
+        {
+            get;set;
+        }
+    }
+}

Examples/SystemCommandsBot/config/Config.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace SystemCommandsBot.config
+{
+    public class Config
+    {
+        public String Password { get; set; }
+
+        public String ApiKey { get; set; }
+
+        public List<commands.Commando> Commandos { get; set; }
+
+
+        public Config()
+        {
+            this.Commandos = new List<commands.Commando>();
+        }
+
+        public void loadDefaultValues()
+        {
+            this.ApiKey = "";
+            this.Commandos.Add(new commands.Commando() { ID = 0, Enabled = true, Title = "Test Befehl", ShellCmd = "explorer.exe", Action = "start", MaxInstances = 2 });
+        }
+
+
+        public static Config load()
+        {
+            try
+            {
+                return load(AppContext.BaseDirectory + "config\\default.cfg");
+
+                
+            }
+            catch(Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+            return null;
+        }
+
+
+        public static Config load(String path)
+        {
+            try
+            {
+                var cfg = Newtonsoft.Json.JsonConvert.DeserializeObject<Config>(File.ReadAllText(path)) as Config;
+                return cfg;
+            }
+            catch (DirectoryNotFoundException ex)
+            {
+                DirectoryInfo di = new DirectoryInfo(path);
+
+                if (!Directory.Exists(di.Parent.FullName))
+                {
+                    Directory.CreateDirectory(di.Parent.FullName);
+                }
+
+                var cfg = new Config();
+                cfg.loadDefaultValues();
+                cfg.save(path);
+                return cfg;
+            }
+            catch (FileNotFoundException ex)
+            {
+                var cfg = new Config();
+                cfg.loadDefaultValues();
+                cfg.save(path);
+                return cfg;
+            }
+            catch(Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+            return null;
+        }
+
+        public void save(String path)
+        {
+            try
+            {
+                File.WriteAllText(path, Newtonsoft.Json.JsonConvert.SerializeObject(this));
+            }
+            catch
+            {
+
+            }
+        }
+    }
+}

Examples/SystemCommandsBot/forms/CmdForm.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace SystemCommandsBot.forms
+{
+    public class CmdForm : TelegramBotBase.Form.AutoCleanForm
+    {
+        public DateTime ExpiresAt { get; set; }
+
+        public int? MessageId { get; set; }
+
+        public override async Task Load(MessageResult message)
+        {
+
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            var btn = message.RawData;
+
+            int id = -1;
+
+            if (!int.TryParse(btn, out id))
+            {
+
+                return;
+            }
+
+            var cmd = Program.BotConfig.Commandos.Where(a => a.Enabled && a.ID == id).FirstOrDefault();
+            if (cmd == null)
+            {
+                await this.Device.Send("Cmd nicht verfügbar.");
+                return;
+            }
+
+            message.Handled = true;
+
+            switch (cmd.Action)
+            {
+                case "start":
+
+                    FileInfo fi = new FileInfo(cmd.ShellCmd);
+
+                    if (cmd.MaxInstances != null && cmd.MaxInstances >= 0)
+                    {
+
+                        if (Process.GetProcessesByName(cmd.ProcName).Count() >= cmd.MaxInstances)
+                        {
+                            await this.Device.Send("Anwendung läuft bereits.");
+                            await message.ConfirmAction("Anwendung läuft bereits.");
+
+                            return;
+                        }
+
+                    }
+
+                    ProcessStartInfo psi = new ProcessStartInfo();
+                    psi.FileName = cmd.ShellCmd;
+                    psi.WorkingDirectory = fi.DirectoryName;
+                    psi.UseShellExecute = cmd.UseShell;
+
+                    Process.Start(psi);
+
+                    await this.Device.Send(fi.Name + " wurde gestarted.");
+
+                    await message.ConfirmAction(fi.Name + " wurde gestarted.");
+
+                    break;
+
+                case "kill":
+
+                    FileInfo fi2 = new FileInfo(cmd.ShellCmd);
+
+                    String pros = fi2.Name.Replace(fi2.Extension, "");
+
+                    var proc = Process.GetProcessesByName(pros).ToList();
+
+                    foreach (var p in proc)
+                    {
+                        try
+                        {
+                            p.Kill();
+                        }
+                        catch
+                        {
+
+                        }
+                    }
+
+                    await this.Device.Send(fi2.Name + " wurde beendet.");
+
+                    await message.ConfirmAction(fi2.Name + " wurde beendet.");
+
+                    break;
+
+                case "restart":
+
+                    FileInfo fi3 = new FileInfo(cmd.ShellCmd);
+
+                    String pros2 = fi3.Name.Replace(fi3.Extension, "");
+
+                    var proc2 = Process.GetProcessesByName(pros2).ToList();
+
+                    foreach (var p in proc2)
+                    {
+                        try
+                        {
+                            p.Kill();
+                        }
+                        catch
+                        {
+
+                        }
+                    }
+
+                    FileInfo fi4 = new FileInfo(cmd.ShellCmd);
+
+                    ProcessStartInfo psi2 = new ProcessStartInfo();
+                    psi2.FileName = cmd.ShellCmd;
+                    psi2.WorkingDirectory = fi4.DirectoryName;
+                    psi2.FileName = cmd.ShellCmd;
+                    psi2.UseShellExecute = cmd.UseShell;
+
+                    Process.Start(psi2);
+
+                    await this.Device.Send(fi3.Name + " wurde neugestarted.");
+                    await message.ConfirmAction(fi3.Name + " wurde neugestarted.");
+
+
+                    break;
+
+                default:
+
+                    await message.ConfirmAction();
+
+                    break;
+
+            }
+
+
+
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            if (this.MessageId == null)
+            {
+                var buttons = Program.BotConfig.Commandos.Where(a => a.Enabled).Select(a => new ButtonBase(a.Title, a.ID.ToString()));
+
+                ButtonForm bf = new ButtonForm();
+                bf.AddSplitted(buttons, 1);
+                await this.Device.Send("Deine Optionen", bf);
+
+                return;
+            }
+
+
+        }
+
+
+
+
+    }
+}

Examples/SystemCommandsBot/forms/StartForm.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+
+namespace SystemCommandsBot.forms
+{
+    public class StartForm : TelegramBotBase.Form.FormBase
+    {
+        public String Password { get; set; }
+
+        public override async Task Load(MessageResult message)
+        {
+            var inp = message.MessageText;
+            if (Program.BotConfig.Password == inp)
+            {
+                this.Password = inp;
+            }
+
+
+        }
+
+
+        public override async Task Render(MessageResult message)
+        {
+            if (this.Password == null || this.Password.Trim() == "")
+            {
+                await this.Device.Send("Bitte gib dein Passwort an.");
+                return;
+            }
+
+
+            var cmd = new forms.CmdForm();
+            cmd.ExpiresAt = DateTime.Now.AddDays(14);
+
+            await this.NavigateTo(cmd);
+
+        }
+
+    }
+}

README.md

@@ -1,4 +1,5 @@
 
+
 # .Net Telegram Bot Framework - Context based addon
 
 [![NuGet version (TelegramBotBase)](https://img.shields.io/nuget/v/TelegramBotBase.svg?style=flat-square)](https://www.nuget.org/packages/TelegramBotBase/)
@@ -12,11 +13,33 @@ Test the Testproject: [@TGBaseBot](https://www.t.me/TGBaseBot)
 
 Join the Telegram Group: [https://www.t.me/tgbotbase](https://www.t.me/tgbotbase)
 
+Download a release: [Releases](https://github.com/MajMcCloud/TelegramBotFramework/releases)
+
+---
+
+Donations
+
+Bitcoin: 1GoUJYMwAvBipQTfw2FKydAz12J8RDyeJs / bc1qqwlp0p5ley29lsu6jhe0qv7s7963kfc7d0m53d
+
+ETH: 0xAf3835104c2C3E5b3e721FA2c7365955e87DB931
+
+Litecoin: LRhF1eB7kneFontcDRDU8YjJhEm2GoYHch
+
+DASH: XudiUwWtSmAJj1QDdVW7jocQumJFLsyoGZ
+
+TRON: TYVZSykaVT1nKZnz9hjDgBRNB9VavU1bpW
+
+BITTORRENT: TYVZSykaVT1nKZnz9hjDgBRNB9VavU1bpW
+
+
+Thanks !
+
 ---
 
 ## Index
 - [Introduction](#introduction)
 - [How to Start](#how-to-start)
+- [Quick Start](#quick-start)
 - [Message Handling](#message-handling)
     * [Example #0 - System Calls](#add-some-system-calls-example-0---system-calls)
 
@@ -36,6 +59,67 @@ Join the Telegram Group: [https://www.t.me/tgbotbase](https://www.t.me/tgbotbase
 	
 	* [PromptDialog](#prompt-dialog)
 
+	* [ConfirmDialog](#confirm-dialog)
+
+- [Controls](#controls)
+	* [ProgressBar](#progress-bar)
+	
+	* [CalendarPicker](#calendar-picker)
+	
+	* [MonthPicker](#month-picker)
+	
+	* [TreeView](#tree-view)
+
+	* [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)
+
+- [State Machine and Session Serialization (v3.0.0)](#statemachine-and-sessions)
+
+    * [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)
 
 ---
 
@@ -55,18 +139,31 @@ 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
 
 
 ```
 
-//Prepare the System
-BotBase<StartForm> bb = new BotBase<StartForm>("{YOUR API KEY}");
+//Prepare the System (New in V5)
+var bb = BotBaseBuilder
+    .Create()
+    .WithAPIKey("{YOUR API KEY}")
+    .DefaultMessageLoop()
+    .WithStartForm<StartForm>()
+    .NoProxy()
+    .CustomCommands(a =>
+    {
+        a.Start("Starts the bot")
 
-//Add Systemcommands if you like, you could catch them later
-bb.SystemCalls.Add("/start");
+    })
+    .NoSerialization()
+    .UseEnglish()
+    .Build();
+
+//Update bot commands to botfather
+bb.UploadBotCommands().Wait();
 
 //Start your Bot
 bb.Start();
@@ -85,29 +182,26 @@ public class StartForm : FormBase
 
         }
 		
-	//Gets invoked during Navigation to this form
-        public override async Task Init(params object[] param)
-        {
-            
-        }
-		
-	//Gets invoked if the form gets opened (with Form.NavigateTo(NewForm))
-        public override async Task Opened()
-        {
+	    //Gets invoked during Navigation to this form
 
-        }
+        //Init() got replaced with event handler
 		
-	//Gets invoked if the form gets leaved
-        public override async Task Closed()
-        {
+    	//Opened() got replaced with event handler
+
+    	//Closed() got replaced with event handler
 
-        }
 		
 	//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)
@@ -148,14 +242,36 @@ var tf = new TestForm();
 await this.NavigateTo(tf);
 ```
 
+## Quick Start:
+
+
+When migrating from a previous version or starting completely new, all these options can be a bit overwhelming.
+For this I added a QuickStart option, directly after the Create call. It just need basic parameters like in earlier versions.
+
+
+```
+
+//Prepare the System (New in V5)
+var bb = BotBaseBuilder
+    .Create()
+    .QuickStart<StartForm>("{YOUR API KEY}")
+    .Build();
+
+//Start your Bot
+bb.Start();
+
+```
+
+
+
 ## Message Handling
 
 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.
@@ -171,15 +287,26 @@ Below we have 4 options.
 
 
 ```
-BotBase<Start> bb = new BotBase<Start>("{YOUR API KEY}");
+var bb = BotBaseBuilder
+    .Create()
+    .WithAPIKey("{YOUR API KEY}")
+    .DefaultMessageLoop()
+    .WithStartForm<Start>()
+    .NoProxy()
+    .CustomCommands(a =>
+    {
+        a.Start("Starts the bot");
+        a.Add("form1","Opens test form 1" );
+        a.Add("form2", "Opens test form 2" );
+        a.Add("params", "Returns all send parameters as a message." );
 
-bb.SystemCalls.Add("/start");
-bb.SystemCalls.Add("/form1");
-bb.SystemCalls.Add("/form2");
 
-bb.SystemCalls.Add("/params");
+    })
+    .NoSerialization()
+    .UseEnglish()
+    .Build();
 
-bb.SystemCall += async (s, en) =>
+bb.BotCommand += async (s, en) =>
 {
 	switch (en.Command)
 	{
@@ -210,6 +337,9 @@ bb.SystemCall += async (s, en) =>
 
 };
 
+//Update Bot commands to botfather
+bb.UploadBotCommands().Wait();
+
 bb.Start();
 
 ```
@@ -219,24 +349,26 @@ On every input the user is sending back to the bot the Action event gets raised.
 
 ### Lets start with text messages (Example #1 - Simple Test)
 
-
+<img src="images/example1.PNG" />
 
 ```
 public class SimpleForm : AutoCleanForm
 {
-        public SimpleForm()
-        {
-            this.DeleteSide = eSide.Both;
-            this.DeleteMode = eDeleteMode.OnLeavingForm;
-        }
+    public SimpleForm()
+    {
+        this.DeleteSide = TelegramBotBase.Enums.eDeleteSide.Both;
+        this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+
+        this.Opened += SimpleForm_Opened;
+    }
 	
-	public override async Task Opened()
-	{
-	    await this.Device.Send("Hello world! (send 'back' to get back to Start)\r\nOr\r\nhi, hello, maybe, bye and ciao");
-	}
+    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");
+    }
 
 
-	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
 
@@ -274,6 +406,7 @@ public class SimpleForm : AutoCleanForm
 
 I using a different base class (AutoCleanForm) I created for a better "feeling" inside the bot which will delete "old" messages from this form. You have some settings within this class to manage when messages should be getting deleted.
 
+<img src="images/example2.PNG" />
 
 ```
 public class ButtonTestForm : AutoCleanForm
@@ -351,6 +484,8 @@ public class ButtonTestForm : AutoCleanForm
 
             btn.AddButtonRow(new ButtonBase("Button 3", new CallbackData("a", "button3").Serialize()), new ButtonBase("Button 4", new CallbackData("a", "button4").Serialize()));
 
+	    btn.AddButtonRow(new ButtonBase("Google.com", "google", "https://www.google.com"), new ButtonBase("Telegram", "telegram", "https://telegram.org/"));
+
             btn.AddButtonRow(new ButtonBase("Back", new CallbackData("a", "back").Serialize()));
 
             await this.Device.Send("Click a button", btn);
@@ -366,6 +501,8 @@ public class ButtonTestForm : AutoCleanForm
 Sometimes it makes sense to show the end user a type of progressbar or status. For this i tried to make a simple control, which is useful for some situations.
 Maybe, if i  got more ideas, i will add other "controls" in the future.
 
+<img src="images/example3.PNG" />
+
 ```
 
 public class ProgressTest : AutoCleanForm
@@ -500,6 +637,14 @@ public override async Task Closed()
 I read it a lot in different Telegram groups that some developers are searching for easy solutions to create context based apps. For this is my project an ideal solution here.
 To give you an example about the possiblities, i added into the Test project an example for a registration form.
 
+<img src="images/example4.1.PNG" />
+
+<img src="images/example4.2.PNG" />
+
+<img src="images/example4.3.PNG" />
+
+<img src="images/example4.4.PNG" />
+
 ```
 
 public class PerForm : AutoCleanForm
@@ -598,7 +743,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.
 
 
@@ -618,15 +763,24 @@ For now we have the following:
 	Makes sense to create a "feeling" of a clean environment for the user. For instance if you have a multilevel menu. This will remove the previously shown menu, and renders the new sub/top level.
 
 - [PromptDialog](#prompt-dialog)
+	A simple dialog which will show a message and then waits for a text input (response).
+
+- [ConfirmDialog](#confirm-dialog)
 	A simple dialog which is able to show multiple buttons and a Text message. The user could select one option and will get redirected to a different form, depending on the click.
 
 ### Alert Dialog
 
+<img src="images/alertdialog.PNG" />
+
 ```
 
-var fto = new TestForm2();
+AlertDialog ad = new AlertDialog("This is a message", "Ok");
 
-AlertDialog ad = new AlertDialog("This is a message", "Ok", fto);
+ad.ButtonClicked += async (s, en) =>
+{
+    var fto = new TestForm2();
+    await this.NavigateTo(fto);
+};
 
 await this.NavigateTo(ad);
 
@@ -635,47 +789,455 @@ await this.NavigateTo(ad);
 
 ### AutoCleanForm
 
-
+No example yet
 
 ### Prompt Dialog
 
-#### Without Eventhandler (pre-init of form necessary)
+<img src="images/promptdialog.PNG" />
+
+
 
 ```
 
-PromptDialog pd = new PromptDialog("Please confirm");
+PromptDialog pd = new PromptDialog("Please tell me your name ?");
 
-pd.AddButton(new ButtonBase("Ok", "ok"));
-pd.AddButton(new ButtonBase("Cancel", "cancel"));
+pd.Completed += async (s, en) =>
+{
+	await this.Device.Send("Hello " + pd.Value);
+};
 
-var tf = new TestForm2();
-
-pd.ButtonForms.Add("ok", tf);
-pd.ButtonForms.Add("cancel", tf);
-
-await this.NavigateTo(pd);
+await this.OpenModal(pd);
 
 ```
 
+### Confirm Dialog
+
+<img src="images/confirmdialog.PNG" />
+
 
-#### With Eventhandler (no pre-init of form necessary)
 
 ```
 
-PromptDialog pd = new PromptDialog("Please confirm", new ButtonBase("Ok", "ok"), new ButtonBase("Cancel", "cancel"));
+ConfirmDialog cd = new ConfirmDialog("Please confirm", new ButtonBase("Ok", "ok"), new ButtonBase("Cancel", "cancel"));
 
-pd.ButtonClicked += async (s, en) =>
+cd.ButtonClicked += async (s, en) =>
 {
     var tf = new TestForm2();
 
     //Remember only to navigate from the current running form. (here it is the prompt dialog, cause we have left the above already)
-    await pd.NavigateTo(tf);
+    await cd.NavigateTo(tf);
 };
 
-await this.NavigateTo(pd);
+await this.NavigateTo(cd);
 
 ```
 
+
+## Controls
+
+### Progress Bar
+<img src="images/progressbar.PNG?raw=true" />
+
+
+### Calendar Picker
+<img src="images/calendarpicker.PNG?raw=true" />
+
+<img src="images/calendarpicker.gif?raw=true" />
+
+### Month Picker
+<img src="images/monthpicker1.PNG?raw=true" />
+<img src="images/monthpicker2.PNG?raw=true" />
+	
+	
+### Tree View
+<img src="images/treeview1.PNG?raw=true" />
+<img src="images/treeview2.PNG?raw=true" />
+<img src="images/treeview3.PNG?raw=true" />
+<img src="images/treeview4.PNG?raw=true" />	
+	
+
+### Toggle Button
+<img src="images/togglebutton.gif?raw=true" />
+
+### 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
+
+For working with groups, there are multiple different tools which helps to work with and allows bot also to manage "Single-User" chats and group chats.
+
+### Splitter Form
+
+
+An easy way to switch between a "Single-User" form and one for managing a group is the SplitterForm base class.
+It calls special methods which you can override and then move from there to the form you need.
+
+The OpenGroup method is the "backup" if OpenChannel or OpenSupergroup is not overridden. Same for Open, it is "backup" if none of the previous methods has been overridden.
+
+
+```
+
+public class Start : SplitterForm
+{
+        public override async Task<bool> Open(MessageResult e)
+        {
+            var st = new Menu();
+            await this.NavigateTo(st);
+
+            return true;
+        }
+
+
+        public override async Task<bool> OpenGroup(MessageResult e)
+        {
+            var st = new Groups.LinkReplaceTest();
+            await this.NavigateTo(st);
+
+            return true;
+        }
+		
+        public override Task<bool> OpenChannel(MessageResult e)
+        {
+            return base.OpenChannel(e);
+        }
+
+        public override Task<bool> OpenSupergroup(MessageResult e)
+        {
+            return base.OpenSupergroup(e);
+        }
+}
+	
+```
+
+
+### Group Form
+
+For managing groups im introducing a new base class called "GroupForm". This one has special events which should make it easier to work with groups and channels.
+In the Example project is a simple example for deleting a url written by a user and incrementing an internal counter. At every url he writes he got blocked for a small amount of time and the messages gots deleted. At 3 "failes" the user gets kicked of the group and blocked.
+
+```
+public class GroupForm : FormBase
+{
+
+
+        public override async Task Load(MessageResult message)
+        {
+            switch (message.MessageType)
+            {
+                case Telegram.Bot.Types.Enums.MessageType.ChatMembersAdded:
+
+                    await OnMemberChanges(new MemberChangeEventArgs(Telegram.Bot.Types.Enums.MessageType.ChatMembersAdded, message, message.RawMessageData.Message.NewChatMembers));
+
+                    break;
+                case Telegram.Bot.Types.Enums.MessageType.ChatMemberLeft:
+
+                    await OnMemberChanges(new MemberChangeEventArgs(Telegram.Bot.Types.Enums.MessageType.ChatMemberLeft, message, message.RawMessageData.Message.LeftChatMember));
+
+                    break;
+
+                case Telegram.Bot.Types.Enums.MessageType.ChatPhotoChanged:
+                case Telegram.Bot.Types.Enums.MessageType.ChatPhotoDeleted:
+                case Telegram.Bot.Types.Enums.MessageType.ChatTitleChanged:
+                case Telegram.Bot.Types.Enums.MessageType.MigratedFromGroup:
+                case Telegram.Bot.Types.Enums.MessageType.MigratedToSupergroup:
+                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));
+
+                    break;
+
+                default:
+
+                    OnMessage(message);
+
+                    break;
+            }
+
+
+        }
+
+        public virtual async Task OnMemberChanges(MemberChangeEventArgs e)
+        {
+
+        }
+
+
+        public virtual async Task OnGroupChanged(GroupChangedEventArgs e)
+        {
+
+        }
+
+
+        public virtual async Task OnMessage(MessageResult e)
+        {
+
+        }
+}
+```
+
+
+## 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
+var bb = BotBaseBuilder
+    .Create()
+    .WithAPIKey("{YOUR API KEY}")
+    .DefaultMessageLoop()
+    .WithStartForm<StartForm>()
+    .NoProxy()
+    .CustomCommands(a =>
+    {
+        a.Start("Starts the bot");
+    })
+    .UseSimpleJSON(AppContext.BaseDirectory + "config\\states.json")
+    .UseEnglish()
+    .Build();
+
+//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
+var bb = BotBaseBuilder
+    .Create()
+    .WithAPIKey("{YOUR API KEY}")
+    .DefaultMessageLoop()
+    .WithStartForm<StartForm>()
+    .NoProxy()
+    .CustomCommands(a =>
+    {
+        a.Start("Starts the bot");
+    })
+    .UseJSON(AppContext.BaseDirectory + "config\\states.json")
+    .UseEnglish()
+    .Build();
+
+//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
+var bb = BotBaseBuilder
+    .Create()
+    .WithAPIKey("{YOUR API KEY}")
+    .DefaultMessageLoop()
+    .WithStartForm<StartForm>()
+    .NoProxy()
+    .CustomCommands(a =>
+    {
+        a.Start("Starts the bot");
+    })
+    .UseXML(AppContext.BaseDirectory + "config\\states.xml")
+    .UseEnglish()
+    .Build();
+
+//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.
+
 ---
 
 I will add more notes to it soon, so stay tuned.

TelegramBaseTest/Program.cs

@@ -1,81 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using TelegramBotBase;
-using TelegramBotBase.Form;
-using TelegramBaseTest.Tests;
-
-namespace TelegramBaseTest
-{
-    class Program
-    {
-        static void Main(string[] args)
-        {
-
-            String APIKey = "{YOUR API KEY}";
-
-            BotBase<Start> bb = new BotBase<Start>(APIKey);
-
-            bb.SystemCalls.Add("/start");
-            bb.SystemCalls.Add("/form1");
-            bb.SystemCalls.Add("/form2");
-            bb.SystemCalls.Add("/params");
-
-            bb.SystemCall += async (s, en) =>
-            {
-                switch (en.Command)
-                {
-                    case "/start":
-
-                        var start = new Start();
-
-                        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;
-                }
-
-            };
-
-            bb.Start();
-
-
-
-            Console.WriteLine("Telegram Bot started...");
-
-            Console.WriteLine("Press q to quit application.");
-
-
-            Console.ReadLine();
-
-            bb.Stop();
-
-        }
-    }
-}

TelegramBaseTest/Tests/Start.cs

@@ -1,108 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using TelegramBotBase.Base;
-using TelegramBotBase.Form;
-
-namespace TelegramBaseTest.Tests
-{
-    public class Start : FormBase
-    {
-
-        public override async Task Action(MessageResult message)
-        {
-            var call = message.GetData<CallbackData>();
-
-            await message.ConfirmAction();
-
-
-            if (call == null)
-                return;
-
-            switch(call.Value)
-            {
-                case "text":
-
-                    var sf = new SimpleForm();
-
-                    await this.NavigateTo(sf);
-
-                    break;
-
-                case "buttons":
-
-                    var bf = new ButtonTestForm();
-
-                    await this.NavigateTo(bf);
-
-                    break;
-
-                case "progress":
-
-                    var pf = new ProgressTest();
-
-                    await this.NavigateTo(pf);
-
-                    break;
-
-                case "registration":
-
-                    var reg = new Register.Start();
-
-                    await this.NavigateTo(reg);
-
-                    break;
-
-                case "form1":
-
-                    var form1 = new TestForm();
-
-                    await this.NavigateTo(form1);
-
-                    break;
-
-                case "form2":
-
-                    var form2 = new TestForm2();
-
-                    await this.NavigateTo(form2);
-
-                    break;
-
-                case "data":
-
-                    message.Handled = true;
-
-                    var data = new DataForm();
-
-                    await this.NavigateTo(data);
-
-                    break;
-            }
-
-
-        }
-
-        public override async Task Render(MessageResult message)
-        {
-
-            ButtonForm btn = new ButtonForm();
-
-            btn.AddButtonRow(new ButtonBase("#1 Simple Text", new CallbackData("a", "text").Serialize()), new ButtonBase("#2 Button Test", new CallbackData("a", "buttons").Serialize()));
-            btn.AddButtonRow(new ButtonBase("#3 Progress Bar", new CallbackData("a", "progress").Serialize()));
-            btn.AddButtonRow(new ButtonBase("#4 Registration Example", new CallbackData("a", "registration").Serialize()));
-
-            btn.AddButtonRow(new ButtonBase("#5 Form1 Command", new CallbackData("a", "form1").Serialize()));
-
-            btn.AddButtonRow(new ButtonBase("#6 Form2 Command", new CallbackData("a", "form2").Serialize()));
-
-            btn.AddButtonRow(new ButtonBase("#7 Data Handling", new CallbackData("a", "data").Serialize()));
-
-            await this.Device.Send("Choose your test:", btn);
-        }
-
-
-    }
-}

TelegramBaseTest/packages.config

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

TelegramBotBase.Extensions.Images/ImageExtensions.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Threading.Tasks;
+using Telegram.Bot.Types.InputFiles;
+using Telegram.Bot.Types;
+using TelegramBotBase.Sessions;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Extensions.Images
+{
+    public static class ImageExtensions
+    {
+        public static Stream ToStream(this Image image, ImageFormat format)
+        {
+            var stream = new System.IO.MemoryStream();
+            image.Save(stream, format);
+            stream.Position = 0;
+            return stream;
+        }
+
+        /// <summary>
+        /// Sends an image
+        /// </summary>
+        /// <param name="image"></param>
+        /// <param name="name"></param>
+        /// <param name="buttons"></param>
+        /// <param name="replyTo"></param>
+        /// <param name="disableNotification"></param>
+        /// <returns></returns>
+        public static async Task<Message> SendPhoto(this DeviceSession session, Image image, String name, String caption, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false)
+        {
+            using (var fileStream = ToStream(image, ImageFormat.Png))
+            {
+                InputOnlineFile fts = new InputOnlineFile(fileStream, name);
+
+                return await session.SendPhoto(fts, caption: caption, buttons, replyTo, disableNotification);
+            }
+        }
+
+        /// <summary>
+        /// Sends an image
+        /// </summary>
+        /// <param name="image"></param>
+        /// <param name="name"></param>
+        /// <param name="buttons"></param>
+        /// <param name="replyTo"></param>
+        /// <param name="disableNotification"></param>
+        /// <returns></returns>
+        public static async Task<Message> SendPhoto(this DeviceSession session, Bitmap image, String name, String caption, ButtonForm buttons = null, int replyTo = 0, bool disableNotification = false)
+        {
+            using (var fileStream = ToStream(image, ImageFormat.Png))
+            {
+                InputOnlineFile fts = new InputOnlineFile(fileStream, name);
+
+                return await session.SendPhoto(fts, caption: caption, buttons, replyTo, disableNotification);
+            }
+        }
+    }
+}

TelegramBotBase.Extensions.Images/README.md

@@ -0,0 +1,8 @@
+# TelegramBotBase.Extensions.Images
+
+[![NuGet version (TelegramBotBase)](https://img.shields.io/nuget/v/TelegramBotBase.Extensions.Images.svg?style=flat-square)](https://www.nuget.org/packages/TelegramBotBase.Extensions.Images/)
+[![telegram chat](https://img.shields.io/badge/Support_Chat-Telegram-blue.svg?style=flat-square)](https://www.t.me/tgbotbase)
+
+
+[![license](https://img.shields.io/github/license/MajMcCloud/telegrambotframework.svg?style=flat-square&maxAge=2592000&label=License)](https://raw.githubusercontent.com/MajMcCloud/TelegramBotFramework/master/LICENCE.md)
+[![downloads](https://img.shields.io/nuget/dt/TelegramBotBase.Extensions.Images.svg?style=flat-square&label=Package%20Downloads)](https://www.nuget.org/packages/TelegramBotBase.Extensions.Images)

TelegramBotBase.Extensions.Images/TelegramBotBase.Extensions.Images.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFrameworks>netstandard2.0;net5;netcoreapp3.1;net6</TargetFrameworks>
+		<RepositoryUrl>https://github.com/MajMcCloud/TelegramBotFramework</RepositoryUrl>
+		<PackageProjectUrl>https://github.com/MajMcCloud/TelegramBotFramework</PackageProjectUrl>
+		<Copyright>MIT</Copyright>
+		<IncludeSymbols>true</IncludeSymbols>
+		<SymbolPackageFormat>snupkg</SymbolPackageFormat>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1">
+		  <PrivateAssets>all</PrivateAssets>
+		  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+		</PackageReference>
+		<PackageReference Include="System.Drawing.Common" Version="6.0.0" />
+		<PackageReference Include="Telegram.Bot" Version="17.0.0" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\TelegramBotBase\TelegramBotBase.csproj" />
+	</ItemGroup>
+
+</Project>

TelegramBotBase.Test/App.config

@@ -1,14 +1,14 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
     <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2"/>
     </startup>
   <runtime>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
-        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-12.0.0.0" newVersion="12.0.0.0" />
+        <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral"/>
+        <bindingRedirect oldVersion="0.0.0.0-12.0.0.0" newVersion="12.0.0.0"/>
       </dependentAssembly>
     </assemblyBinding>
   </runtime>
-</configuration>
+</configuration>

TelegramBotBase.Test/Program.cs

@@ -0,0 +1,109 @@
+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;
+using TelegramBotBase.Builder;
+
+namespace TelegramBotBaseTest
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+
+            String APIKey = "";
+
+            var bb = BotBaseBuilder
+                      .Create()
+                      .WithAPIKey(APIKey)
+                      .DefaultMessageLoop()
+                      .WithStartForm<Start>()
+                      .NoProxy()
+                      .CustomCommands(a =>
+                      {
+                          a.Start("Starts the bot");
+                          a.Help("Should show you some help");
+                          a.Settings("Should show you some settings");
+                          a.Add("form1", "Opens test form 1");
+                          a.Add("form2", "Opens test form 2");
+                          a.Add("params", "Returns all send parameters as a message.");
+                      })
+                      .NoSerialization()
+                      .UseEnglish()
+                      .Build();
+
+
+            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();
+
+        }
+
+
+    }
+}

TelegramBotBase.Test/Properties/AssemblyInfo.cs

@@ -5,11 +5,11 @@ 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("TelegramBaseTest")]
+[assembly: AssemblyTitle("TelegramBotBaseTest")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("TelegramBaseTest")]
+[assembly: AssemblyProduct("TelegramBotBaseTest")]
 [assembly: AssemblyCopyright("Copyright ©  2017")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]

TelegramBotBase.Test/TelegramBotBaseTest.csproj

@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>netcoreapp3.1;net5;net6</TargetFrameworks>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <Configurations>Debug;Release</Configurations>
+  </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>
+    <ProjectReference Include="..\TelegramBotBase.Extensions.Images\TelegramBotBase.Extensions.Images.csproj" />
+    <ProjectReference Include="..\TelegramBotBase\TelegramBotBase.csproj" />
+  </ItemGroup>
+
+</Project>

TelegramBotBase.Test/Tests/ButtonTestForm.cs

@@ -6,12 +6,17 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests
+namespace TelegramBotBaseTest.Tests
 {
     public class ButtonTestForm : AutoCleanForm
     {
 
-        public override async Task Opened()
+        public ButtonTestForm()
+        {
+            this.Opened += ButtonTestForm_Opened;
+        }
+
+        private async Task ButtonTestForm_Opened(object sender, EventArgs e)
         {
             await this.Device.Send("Hello world! (Click 'back' to get back to Start)");
         }
@@ -57,7 +62,7 @@ namespace TelegramBaseTest.Tests
 
                 case "back":
 
-                    var st = new Start();
+                    var st = new Menu();
 
                     await this.NavigateTo(st);
 
@@ -83,6 +88,8 @@ namespace TelegramBaseTest.Tests
 
             btn.AddButtonRow(new ButtonBase("Button 3", new CallbackData("a", "button3").Serialize()), new ButtonBase("Button 4", new CallbackData("a", "button4").Serialize()));
 
+            btn.AddButtonRow(new ButtonBase("Google.com", "google", "https://www.google.com"), new ButtonBase("Telegram", "telegram", "https://telegram.org/"));
+
             btn.AddButtonRow(new ButtonBase("Back", new CallbackData("a", "back").Serialize()));
 
             await this.Device.Send("Click a button", btn);

TelegramBotBase.Test/Tests/Controls/ButtonGridForm.cs

@@ -0,0 +1,81 @@
+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 ButtonGridForm : AutoCleanForm
+    {
+
+        ButtonGrid m_Buttons = null;
+
+        public ButtonGridForm()
+        {
+            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.InlineKeyBoard;
+
+            ButtonForm bf = new ButtonForm();
+
+            bf.AddButtonRow(new ButtonBase("Back", "back"), new ButtonBase("Switch Keyboard", "switch"));
+
+            bf.AddButtonRow(new ButtonBase("Button1", "b1"), new ButtonBase("Button2", "b2"));
+
+            bf.AddButtonRow(new ButtonBase("Button3", "b3"), new ButtonBase("Button4", "b4"));
+
+            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 if (e.Button.Value == "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;
+                }
+
+
+            }
+            else
+            {
+
+                await this.Device.Send($"Button clicked with Text: {e.Button.Text} and Value {e.Button.Value}");
+            }
+
+
+        }
+    }
+}

TelegramBotBase.Test/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}");
+            }
+
+
+        }
+    }
+}

TelegramBotBase.Test/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}");
+        }
+    }
+}

TelegramBotBase.Test/Tests/Controls/CalendarPickerForm.cs

@@ -0,0 +1,81 @@
+using System;
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+using TelegramBotBase.Controls;
+using TelegramBotBase.Args;
+using TelegramBotBase.Controls.Inline;
+
+namespace TelegramBotBaseTest.Tests.Controls
+{
+    public class CalendarPickerForm : AutoCleanForm
+    {
+
+        public CalendarPicker Picker { get; set; }
+
+        int? selectedDateMessage { get; set; }
+
+        public CalendarPickerForm()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+            this.Init += CalendarPickerForm_Init;
+        }
+
+        private async Task CalendarPickerForm_Init(object sender, InitEventArgs e)
+        {
+            this.Picker = new CalendarPicker();
+            this.Picker.Title = "Datum auswählen / Pick date";
+            
+            this.AddControl(Picker);
+        }
+
+
+        public override async Task Action(MessageResult message)
+        {
+
+            switch(message.RawData)
+            {
+                case "back":
+
+                    var s = new Menu();
+
+                    await this.NavigateTo(s);
+
+                    break;
+            }
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            String s = "";
+
+            s = "Selected date is " + this.Picker.SelectedDate.ToShortDateString() + "\r\n";
+            s += "Selected month is " + this.Picker.Culture.DateTimeFormat.MonthNames[this.Picker.VisibleMonth.Month - 1] + "\r\n";
+            s += "Selected year is " + this.Picker.VisibleMonth.Year.ToString();
+
+            ButtonForm bf = new ButtonForm();
+            bf.AddButtonRow(new ButtonBase("Back","back"));
+
+            if (selectedDateMessage != null)
+            {
+                await this.Device.Edit(this.selectedDateMessage.Value, s, bf);
+            }
+            else
+            {
+                var m = await this.Device.Send(s, bf);
+                this.selectedDateMessage = m.MessageId;
+            }
+
+
+
+        }
+
+
+
+    }
+}

TelegramBotBase.Test/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;
+            }
+
+
+        }
+    }
+}

TelegramBotBase.Test/Tests/Controls/MonthPickerForm.cs

@@ -0,0 +1,79 @@
+using System;
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+using TelegramBotBase.Controls;
+using TelegramBotBase.Args;
+using TelegramBotBase.Controls.Inline;
+
+namespace TelegramBotBaseTest.Tests.Controls
+{
+    public class MonthPickerForm : AutoCleanForm
+    {
+
+        public MonthPicker Picker { get; set; }
+
+        int? selectedDateMessage { get; set; }
+
+        public MonthPickerForm()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+            this.Init += MonthPickerForm_Init;
+        }
+
+        private async Task MonthPickerForm_Init(object sender, InitEventArgs e)
+        {
+            this.Picker = new MonthPicker();
+            this.Picker.Title = "Monat auswählen / Pick month";
+            this.AddControl(Picker);
+        }
+
+
+        public override async Task Action(MessageResult message)
+        {
+
+            switch(message.RawData)
+            {
+                case "back":
+
+                    var s = new Menu();
+
+                    await this.NavigateTo(s);
+
+                    break;
+            }
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            String s = "";
+
+            s += "Selected month is " + this.Picker.Culture.DateTimeFormat.MonthNames[this.Picker.SelectedDate.Month - 1] + "\r\n";
+            s += "Selected year is " + this.Picker.VisibleMonth.Year.ToString();
+
+            ButtonForm bf = new ButtonForm();
+            bf.AddButtonRow(new ButtonBase("Back","back"));
+
+            if (selectedDateMessage != null)
+            {
+                await this.Device.Edit(this.selectedDateMessage.Value, s, bf);
+            }
+            else
+            {
+                var m = await this.Device.Send(s, bf);
+                this.selectedDateMessage = m.MessageId;
+            }
+
+
+
+        }
+
+
+
+    }
+}

TelegramBotBase.Test/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.");
+        }
+    }
+}

TelegramBotBase.Test/Tests/Controls/MultiViewForm.cs

@@ -0,0 +1,53 @@
+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;
+            }
+        }
+
+
+    }
+}

TelegramBotBase.Test/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;
+
+
+            }
+
+        }
+
+
+
+    }
+}

TelegramBotBase.Test/Tests/Controls/ToggleButtons.cs

@@ -0,0 +1,51 @@
+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 ToggleButtons : AutoCleanForm
+    {
+        public ToggleButtons()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+
+            this.Init += ToggleButtons_Init;
+        }
+
+        private async Task ToggleButtons_Init(object sender, InitEventArgs e)
+        {
+
+            var tb = new ToggleButton();
+            tb.Checked = true;
+            tb.Toggled += Tb_Toggled;
+
+            this.AddControl(tb);
+
+            tb = new ToggleButton();
+            tb.Checked = false;
+            tb.Toggled += Tb_Toggled;
+
+            this.AddControl(tb);
+
+            tb = new ToggleButton();
+            tb.Checked = true;
+            tb.Toggled += Tb_Toggled;
+
+            this.AddControl(tb);
+
+        }
+
+        private void Tb_Toggled(object sender, EventArgs e)
+        {
+            var tb = sender as ToggleButton;
+            Console.WriteLine(tb.ID.ToString() + " was pressed, and toggled to " + (tb.Checked ? "Checked" : "Unchecked"));
+        }
+    }
+}

TelegramBotBase.Test/Tests/Controls/TreeViewForms.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Form;
+using TelegramBotBase.Controls;
+using TelegramBotBase.Base;
+using TelegramBotBase.Args;
+using TelegramBotBase.Controls.Inline;
+
+namespace TelegramBotBaseTest.Tests.Controls
+{
+    public class TreeViewForms : AutoCleanForm
+    {
+        public TreeView view { get; set; }
+
+        private int? MessageId { get; set; }
+
+        public TreeViewForms()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+            this.Init += TreeViewForms_Init;
+        }
+
+        private async Task TreeViewForms_Init(object sender, InitEventArgs e)
+        {
+            view = new TreeView();
+
+            var tvn = new TreeViewNode("Cars", "cars");
+
+            tvn.AddNode(new TreeViewNode("Porsche", "porsche", new TreeViewNode("Website", "web", "https://www.porsche.com/germany/"), new TreeViewNode("911", "911"), new TreeViewNode("918 Spyder", "918")));
+            tvn.AddNode(new TreeViewNode("BMW", "bmw"));
+            tvn.AddNode(new TreeViewNode("Audi", "audi"));
+            tvn.AddNode(new TreeViewNode("VW", "vw"));
+            tvn.AddNode(new TreeViewNode("Lamborghini", "lamborghini"));
+
+            view.Nodes.Add(tvn);
+
+            tvn = new TreeViewNode("Fruits", "fruits");
+
+            tvn.AddNode(new TreeViewNode("Apple", "apple"));
+            tvn.AddNode(new TreeViewNode("Orange", "orange"));
+            tvn.AddNode(new TreeViewNode("Lemon", "lemon"));
+
+            view.Nodes.Add(tvn);
+
+            this.AddControl(view);
+
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            await message.ConfirmAction();
+
+            if (message.Handled)
+                return;
+
+            switch (message.RawData)
+            {
+                case "back":
+
+                    message.Handled = true;
+
+                    var start = new Menu();
+
+                    await this.NavigateTo(start);
+
+                    break;
+
+            }
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            String s = "";
+
+            s += "Selected Node: " + (this.view.SelectedNode?.Text ?? "(null)") + "\r\n";
+
+            s += "Visible Node: " + (this.view.VisibleNode?.Text ?? "(top)") + "\r\n";
+
+            s += "Visible Path: " + this.view.GetPath() + "\r\n";
+            s += "Selected Path: " + (this.view.SelectedNode?.GetPath() ?? "(null)") + "\r\n";
+
+            ButtonForm bf = new ButtonForm();
+            bf.AddButtonRow(new ButtonBase("Back", "back"));
+
+            if (MessageId != null)
+            {
+                await this.Device.Edit(this.MessageId.Value, s, bf);
+            }
+            else
+            {
+                var m = await this.Device.Send(s, bf);
+                this.MessageId = m.MessageId;
+            }
+        }
+
+    }
+}

TelegramBotBase.Test/Tests/DataForm.cs

@@ -3,13 +3,14 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Telegram.Bot;
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.InputFiles;
 using Telegram.Bot.Types.ReplyMarkups;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests
+namespace TelegramBotBaseTest.Tests
 {
     public class DataForm : AutoCleanForm
     {
@@ -110,7 +111,7 @@ namespace TelegramBaseTest.Tests
 
                     message.Handled = true;
 
-                    var start = new Start();
+                    var start = new Menu();
 
                     await this.NavigateTo(start);
 

TelegramBotBase.Test/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;
+            }
+        }
+
+    }
+}

TelegramBotBase.Test/Tests/Datasources/List.cs

@@ -0,0 +1,54 @@
+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;
+            }
+        }
+
+
+    }
+}

TelegramBotBase.Test/Tests/Groups/GroupChange.cs

@@ -0,0 +1,76 @@
+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.Groups
+{
+    public class GroupChange : TelegramBotBase.Form.GroupForm
+    {
+        public GroupChange()
+        {
+            this.Opened += GroupChange_Opened;
+        }
+
+
+        private async Task GroupChange_Opened(object sender, EventArgs e)
+        {
+
+            ButtonForm bf = new ButtonForm();
+
+            bf.AddButtonRow(new ButtonBase("Open GroupChange Test", "groupchange"));
+            bf.AddButtonRow(new ButtonBase("Open WelcomeUser Test", "welcomeuser"));
+            bf.AddButtonRow(new ButtonBase("Open LinkReplace Test", "linkreplace"));
+
+            await this.Device.Send("GroupChange started, click to switch", bf);
+
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.Handled)
+                return;
+
+
+            var bn = message.RawData;
+
+            await message.ConfirmAction();
+            message.Handled = true;
+
+            switch (bn)
+            {
+                case "groupchange":
+
+                    var gc = new GroupChange();
+
+                    await this.NavigateTo(gc);
+
+                    break;
+                case "welcomeuser":
+
+                    var wu = new WelcomeUser();
+
+                    await this.NavigateTo(wu);
+
+                    break;
+                case "linkreplace":
+
+                    var lr = new LinkReplaceTest();
+
+                    await this.NavigateTo(lr);
+
+                    break;
+            }
+
+        }
+
+        public override async Task OnGroupChanged(GroupChangedEventArgs e)
+        {
+            await this.Device.Send("Group has been changed by " + e.OriginalMessage.Message.From.FirstName + " " + e.OriginalMessage.Message.From.LastName);
+        }
+
+    }
+}

TelegramBotBase.Test/Tests/Groups/LinkReplaceTest.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Telegram.Bot.Types;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Groups
+{
+    public class LinkReplaceTest : TelegramBotBase.Form.GroupForm
+    {
+
+        Dictionary<long, int> Counter { get; set; } = new Dictionary<long, int>();
+
+        private const int Maximum = 3;
+
+
+        public LinkReplaceTest()
+        {
+            this.Opened += LinkReplaceTest_Opened;
+        }
+
+        private async Task LinkReplaceTest_Opened(object sender, EventArgs e)
+        {
+
+            ButtonForm bf = new ButtonForm();
+
+            bf.AddButtonRow(new ButtonBase("Open GroupChange Test", "groupchange"));
+            bf.AddButtonRow(new ButtonBase("Open WelcomeUser Test", "welcomeuser"));
+            bf.AddButtonRow(new ButtonBase("Open LinkReplace Test", "linkreplace"));
+
+            await this.Device.Send("LinkReplaceTest started, click to switch", bf);
+
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.Handled)
+                return;
+
+            var bn = message.RawData;
+
+            await message.ConfirmAction();
+            message.Handled = true;
+
+            switch (bn)
+            {
+                case "groupchange":
+
+                    var gc = new GroupChange();
+
+                    await this.NavigateTo(gc);
+
+                    break;
+                case "welcomeuser":
+
+                    var wu = new WelcomeUser();
+
+                    await this.NavigateTo(wu);
+
+                    break;
+                case "linkreplace":
+
+                    var lr = new LinkReplaceTest();
+
+                    await this.NavigateTo(lr);
+
+                    break;
+            }
+
+        }
+
+        public override async Task OnMessage(MessageResult e)
+        {
+            var from = e.Message.From.Id;
+
+            if (e.Message.From.IsBot)
+                return;
+
+            //Are urls inside his message ?
+            if (!HasLinks(e.MessageText))
+                return;
+
+            var u = await Device.GetChatUser(from);
+
+            //Don't kick Admins or Creators
+            if (u.Status == Telegram.Bot.Types.Enums.ChatMemberStatus.Administrator | u.Status == Telegram.Bot.Types.Enums.ChatMemberStatus.Creator)
+            {
+                await this.Device.Send("You won't get kicked,...not this time.");
+                return;
+            }
+
+            await e.Device.DeleteMessage(e.MessageId);
+
+            var cp = new ChatPermissions();
+            cp.CanAddWebPagePreviews = false;
+            cp.CanChangeInfo = false;
+            cp.CanInviteUsers = false;
+            cp.CanPinMessages = false;
+            cp.CanSendMediaMessages = false;
+            cp.CanSendMessages = false;
+            cp.CanSendOtherMessages = false;
+            cp.CanSendPolls = false;
+
+            //Collect user "mistakes" with sending url, after 3 he gets kicked out.
+            if (Counter.ContainsKey(from))
+            {
+                Counter[from]++;
+            }
+            else
+            {
+                Counter[from] = 1;
+            }
+
+
+            if (Counter[from] >= 3)
+            {
+                await e.Device.KickUser(from);
+
+                await e.Device.Send(e.Message.From.FirstName + " " + e.Message.From.LastName + " has been removed from the group");
+            }
+            else
+            {
+                await e.Device.RestrictUser(from, cp, DateTime.UtcNow.AddSeconds(30));
+
+                await e.Device.Send(e.Message.From.FirstName + " " + e.Message.From.LastName + " has been blocked for 30 seconds");
+            }
+
+
+
+        }
+
+        /// <summary>
+        /// Call onmessage also on edited message, if someone want to spoof a failed message and insert a link.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public override async Task OnMessageEdit(MessageResult message)
+        {
+            await OnMessage(message);
+        }
+
+        /// <summary>
+        /// https://stackoverflow.com/a/20651284
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        private bool HasLinks(String str)
+        {
+            var tmp = str;
+
+            var pattern = @"^(http|https|ftp|)\://|[a-zA-Z0-9\-\.]+\.[a-zA-Z](:[a-zA-Z0-9]*)?/?([a-zA-Z0-9\-\._\?\,\'/\\\+&amp;%\$#\=~])*[^\.\,\)\(\s]$";
+            Regex r = new Regex(pattern);
+
+            var matches = r.Matches(tmp);
+
+            return (matches.Count > 0);
+        }
+
+
+    }
+}

TelegramBotBase.Test/Tests/Groups/WelcomeUser.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Linq;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+using TelegramBotBase.Args;
+
+namespace TelegramBotBaseTest.Tests.Groups
+{
+    public class WelcomeUser : TelegramBotBase.Form.GroupForm
+    {
+
+        public WelcomeUser()
+        {
+            this.Opened += WelcomeUser_Opened;
+        }
+
+
+        private async Task WelcomeUser_Opened(object sender, EventArgs e)
+        {
+
+            ButtonForm bf = new ButtonForm();
+
+            bf.AddButtonRow(new ButtonBase("Open GroupChange Test", "groupchange"));
+            bf.AddButtonRow(new ButtonBase("Open WelcomeUser Test", "welcomeuser"));
+            bf.AddButtonRow(new ButtonBase("Open LinkReplace Test", "linkreplace"));
+
+            await this.Device.Send("WelcomeUser started, click to switch", bf);
+
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.Handled)
+                return;
+
+            var bn = message.RawData;
+
+            await message.ConfirmAction();
+            message.Handled = true;
+
+            switch (bn)
+            {
+                case "groupchange":
+
+                    var gc = new GroupChange();
+
+                    await this.NavigateTo(gc);
+
+                    break;
+                case "welcomeuser":
+
+                    var wu = new WelcomeUser();
+
+                    await this.NavigateTo(wu);
+
+                    break;
+                case "linkreplace":
+
+                    var lr = new LinkReplaceTest();
+
+                    await this.NavigateTo(lr);
+
+                    break;
+            }
+
+        }
+
+        public override async Task OnMemberChanges(MemberChangeEventArgs e)
+        {
+
+            if (e.Type == Telegram.Bot.Types.Enums.MessageType.ChatMembersAdded)
+            {
+
+                await this.Device.Send("Welcome you new members!\r\n\r\n" + e.Members.Select(a => a.FirstName + " " + a.LastName).Aggregate((a, b) => a + "\r\n" + b));
+
+            }
+            else if (e.Type == Telegram.Bot.Types.Enums.MessageType.ChatMemberLeft)
+            {
+                await this.Device.Send(e.Members.Select(a => a.FirstName + " " + a.LastName).Aggregate((a, b) => a + " and " + b) + " has left the group");
+
+            }
+
+        }
+
+
+
+
+    }
+}

TelegramBotBase.Test/Tests/Menu.cs

@@ -0,0 +1,264 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+using TelegramBotBaseTest.Tests.Controls;
+
+namespace TelegramBotBaseTest.Tests
+{
+    public class Menu : AutoCleanForm
+    {
+        public Menu()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+        }
+
+        public override async Task Load(MessageResult message)
+        {
+
+
+            if (message.Message.Chat.Type == Telegram.Bot.Types.Enums.ChatType.Group | message.Message.Chat.Type == Telegram.Bot.Types.Enums.ChatType.Supergroup)
+            {
+                var sf = new TelegramBotBaseTest.Tests.Groups.WelcomeUser();
+
+                await this.NavigateTo(sf);
+            }
+
+
+            await Device.HideReplyKeyboard();
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            var call = message.GetData<CallbackData>();
+
+            await message.ConfirmAction();
+
+
+            if (call == null)
+                return;
+
+            message.Handled = true;
+
+            switch (call.Value)
+            {
+                case "text":
+
+                    var sf = new SimpleForm();
+
+                    await this.NavigateTo(sf);
+
+                    break;
+
+                case "buttons":
+
+                    var bf = new ButtonTestForm();
+
+                    await this.NavigateTo(bf);
+
+                    break;
+
+                case "progress":
+
+                    var pf = new ProgressTest();
+
+                    await this.NavigateTo(pf);
+
+                    break;
+
+                case "registration":
+
+                    var reg = new Register.Start();
+
+                    await this.NavigateTo(reg);
+
+                    break;
+
+                case "form1":
+
+                    var form1 = new TestForm();
+
+                    await this.NavigateTo(form1);
+
+                    break;
+
+                case "form2":
+
+                    var form2 = new TestForm2();
+
+                    await this.NavigateTo(form2);
+
+                    break;
+
+                case "data":
+
+                    var data = new DataForm();
+
+                    await this.NavigateTo(data);
+
+                    break;
+
+                case "calendar":
+
+                    var calendar = new Controls.CalendarPickerForm();
+
+                    await this.NavigateTo(calendar);
+
+                    break;
+
+                case "month":
+
+                    var month = new Controls.MonthPickerForm();
+
+                    await this.NavigateTo(month);
+
+                    break;
+
+                case "treeview":
+
+                    var tree = new Controls.TreeViewForms();
+
+                    await this.NavigateTo(tree);
+
+                    break;
+
+                case "togglebuttons":
+
+                    var tb = new Controls.ToggleButtons();
+
+                    await this.NavigateTo(tb);
+
+                    break;
+
+                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;
+            }
+
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+
+            ButtonForm btn = new ButtonForm();
+
+            btn.AddButtonRow(new ButtonBase("#1 Simple Text", new CallbackData("a", "text").Serialize()), new ButtonBase("#2 Button Test", new CallbackData("a", "buttons").Serialize()));
+            btn.AddButtonRow(new ButtonBase("#3 Progress Bar", new CallbackData("a", "progress").Serialize()));
+            btn.AddButtonRow(new ButtonBase("#4 Registration Example", new CallbackData("a", "registration").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#5 Form1 Command", new CallbackData("a", "form1").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#6 Form2 Command", new CallbackData("a", "form2").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#7 Data Handling", new CallbackData("a", "data").Serialize()));
+            btn.AddButtonRow(new ButtonBase("#8 Calendar Picker", new CallbackData("a", "calendar").Serialize()));
+            btn.AddButtonRow(new ButtonBase("#9 Month Picker", new CallbackData("a", "month").Serialize()));
+
+            btn.AddButtonRow(new ButtonBase("#10 TreeView", new CallbackData("a", "treeview").Serialize()));
+
+            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);
+        }
+
+
+    }
+}

TelegramBotBase.Test/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();
+        }
+
+    }
+}

TelegramBotBase.Test/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);
+
+        }
+
+
+    }
+}

TelegramBotBase.Test/Tests/Navigation/Start.cs

@@ -0,0 +1,91 @@
+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()
+        {
+
+        }
+
+
+        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);
+                    nc.ForceCleanupOnLastPop = true;
+
+                    var f1 = new Form1();
+
+                    await nc.PushAsync(f1);
+
+                    await NavigateTo(nc);
+
+                    if (msg == null)
+                        return;
+
+                    await Device.DeleteMessage(msg);
+
+
+                    break;
+                case "no":
+
+                    message.Handled = true;
+
+                    var mn = new Menu();
+
+                    await NavigateTo(mn);
+
+                    if (msg == null)
+                        return;
+
+                    await Device.DeleteMessage(msg);
+
+                    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);
+
+
+        }
+
+    }
+}

TelegramBotBase.Test/Tests/Notifications/Start.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests.Notifications
+{
+    public class Start : AutoCleanForm
+    {
+        bool sent = false;
+
+        public Start()
+        {
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+        }
+
+        public override async Task Action(MessageResult message)
+        {
+            if (message.Handled)
+                return;
+
+            switch (message.RawData)
+            {
+                case "alert":
+
+                    await message.ConfirmAction("This is an alert.", true);
+
+                    break;
+                case "back":
+
+                    var mn = new Menu();
+                    await NavigateTo(mn);
+
+                    break;
+                default:
+
+                    await message.ConfirmAction("This is feedback");
+
+                    break;
+
+            }
+
+        }
+
+        public override async Task Render(MessageResult message)
+        {
+            if (sent)
+                return;
+
+            var bf = new ButtonForm();
+            bf.AddButtonRow("Normal feeback", "normal");
+            bf.AddButtonRow("Alert Box", "alert");
+            bf.AddButtonRow("Back", "back");
+
+            await Device.Send("Choose your test", bf);
+
+            sent = true;
+        }
+
+    }
+}

TelegramBotBase.Test/Tests/ProgressTest.cs

@@ -5,19 +5,23 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using TelegramBotBase.Base;
+using TelegramBotBase.Controls.Inline;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests
+namespace TelegramBotBaseTest.Tests
 {
     public class ProgressTest : AutoCleanForm
     {
 
         public ProgressTest()
         {
-            this.DeleteMode = eDeleteMode.OnLeavingForm;
+            this.DeleteMode = TelegramBotBase.Enums.eDeleteMode.OnLeavingForm;
+            this.Opened += ProgressTest_Opened;
+            this.Closed += ProgressTest_Closed;
         }
 
-        public override async Task Opened()
+
+        private async Task ProgressTest_Opened(object sender, EventArgs e)
         {
             await this.Device.Send("Welcome to ProgressTest");
         }
@@ -32,48 +36,48 @@ namespace TelegramBaseTest.Tests
             if (call == null)
                 return;
 
-            TelegramBotBase.Controls.ProgressBar Bar = null;
+            ProgressBar Bar = null;
 
             switch (call.Value)
             {
                 case "standard":
 
-                    Bar = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.standard);
+                    Bar = new ProgressBar(0, 100, ProgressBar.eProgressStyle.standard);
                     Bar.Device = this.Device;
 
                     break;
 
                 case "squares":
 
-                    Bar = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.squares);
+                    Bar = new ProgressBar(0, 100, ProgressBar.eProgressStyle.squares);
                     Bar.Device = this.Device;
 
                     break;
 
                 case "circles":
 
-                    Bar = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.circles);
+                    Bar = new ProgressBar(0, 100, ProgressBar.eProgressStyle.circles);
                     Bar.Device = this.Device;
 
                     break;
 
                 case "lines":
 
-                    Bar = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.lines);
+                    Bar = new ProgressBar(0, 100, ProgressBar.eProgressStyle.lines);
                     Bar.Device = this.Device;
 
                     break;
 
                 case "squaredlines":
 
-                    Bar = new TelegramBotBase.Controls.ProgressBar(0, 100, TelegramBotBase.Controls.ProgressBar.eProgressStyle.squaredLines);
+                    Bar = new ProgressBar(0, 100, ProgressBar.eProgressStyle.squaredLines);
                     Bar.Device = this.Device;
 
                     break;
 
                 case "start":
 
-                    var sf = new Start();
+                    var sf = new Menu();
 
                     await this.NavigateTo(sf);
 
@@ -87,14 +91,14 @@ namespace TelegramBaseTest.Tests
 
 
             //Render Progress bar and show some "example" progress
-            await Bar.Render();
+            await Bar.Render(message);
 
             this.Controls.Add(Bar);
 
             for (int i = 0; i <= 100; i++)
             {
                 Bar.Value++;
-                await Bar.Render();
+                await Bar.Render(message);
 
                 Thread.Sleep(250);
             }
@@ -117,17 +121,10 @@ namespace TelegramBaseTest.Tests
             await this.Device.Send("Choose your progress bar:", btn);
         }
 
-        public override async Task Closed()
+        private async Task ProgressTest_Closed(object sender, EventArgs e)
         {
-            foreach (var b in this.Controls)
-            {
-                await b.Cleanup();
-            }
-
             await this.Device.Send("Ciao from ProgressTest");
         }
 
-
-
     }
 }

TelegramBotBase.Test/Tests/Register/PerForm.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests.Register
+namespace TelegramBotBaseTest.Tests.Register
 {
     public class PerForm : AutoCleanForm
     {

TelegramBotBase.Test/Tests/Register/PerStep.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests.Register
+namespace TelegramBotBaseTest.Tests.Register
 {
     public class PerStep: AutoCleanForm
     {

TelegramBotBase.Test/Tests/Register/Start.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests.Register
+namespace TelegramBotBaseTest.Tests.Register
 {
     public class Start : AutoCleanForm
     {
@@ -43,7 +43,7 @@ namespace TelegramBaseTest.Tests.Register
                     break;
                 case "backtodashboard":
 
-                    var start = new Tests.Start();
+                    var start = new Tests.Menu();
 
                     await this.NavigateTo(start);
 

TelegramBotBase.Test/Tests/Register/Steps/Data.cs

@@ -4,7 +4,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace TelegramBaseTest.Tests.Register.Steps
+namespace TelegramBotBaseTest.Tests.Register.Steps
 {
     public class Data
     {

TelegramBotBase.Test/Tests/Register/Steps/Step1.cs

@@ -3,20 +3,27 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using TelegramBotBase.Args;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests.Register.Steps
+namespace TelegramBotBaseTest.Tests.Register.Steps
 {
     public class Step1 : AutoCleanForm
     {
         public Data UserData { get; set; }
 
-        public async override Task Init(params object[] args)
+        public Step1()
+        {
+            this.Init += Step1_Init;
+        }
+
+        private async Task Step1_Init(object sender, InitEventArgs e)
         {
             this.UserData = new Data();
         }
 
+
         public async override Task Load(MessageResult message)
         {
             if (message.Handled)

TelegramBotBase.Test/Tests/Register/Steps/Step2.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests.Register.Steps
+namespace TelegramBotBaseTest.Tests.Register.Steps
 {
     public class Step2 : AutoCleanForm
     {

TelegramBotBase.Test/Tests/Register/Steps/Step3.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests.Register.Steps
+namespace TelegramBotBaseTest.Tests.Register.Steps
 {
     public class Step3 : AutoCleanForm
     {

TelegramBotBase.Test/Tests/SimpleForm.cs

@@ -6,23 +6,24 @@ using System.Threading.Tasks;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests
+namespace TelegramBotBaseTest.Tests
 {
     public class SimpleForm : AutoCleanForm
     {
 
         public SimpleForm()
         {
-            this.DeleteSide = eSide.Both;
-            this.DeleteMode = eDeleteMode.OnLeavingForm;
+            this.DeleteSide = TelegramBotBase.Enums.eDeleteSide.Both;
+            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");
         }
 
-
         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
@@ -54,7 +55,7 @@ namespace TelegramBaseTest.Tests
 
                 case "back":
 
-                    var st = new Start();
+                    var st = new Menu();
 
                     await this.NavigateTo(st);
 

TelegramBotBase.Test/Tests/Start.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Base;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBaseTest.Tests
+{
+    public class Start : SplitterForm
+    {
+        public override async Task<bool> Open(MessageResult e)
+        {
+            var st = new Menu();
+            await this.NavigateTo(st);
+
+            return true;
+        }
+
+
+        public override async Task<bool> OpenGroup(MessageResult e)
+        {
+            var st = new Groups.LinkReplaceTest();
+            await this.NavigateTo(st);
+
+            return true;
+        }
+
+        public override Task<bool> OpenChannel(MessageResult e)
+        {
+            return base.OpenChannel(e);
+        }
+
+        public override Task<bool> OpenSupergroup(MessageResult e)
+        {
+            return base.OpenSupergroup(e);
+        }
+
+    }
+}

TelegramBotBase.Test/Tests/TestForm.cs

@@ -7,7 +7,7 @@ using Telegram.Bot.Types;
 using TelegramBotBase.Base;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests
+namespace TelegramBotBaseTest.Tests
 {
     public class TestForm : FormBase
     {
@@ -15,13 +15,18 @@ namespace TelegramBaseTest.Tests
 
         String LastMessage { get; set; }
 
+        public TestForm()
+        {
+            this.Opened += TestForm_Opened;
+            this.Closed += TestForm_Closed;
+        }
 
-        public override async Task Opened()
+        private async Task TestForm_Opened(object sender, EventArgs e)
         {
             await this.Device.Send("Welcome to Form 1");
         }
 
-        public override async Task Closed()
+        private async Task TestForm_Closed(object sender, EventArgs e)
         {
             await this.Device.Send("Ciao from Form 1");
         }
@@ -33,7 +38,6 @@ namespace TelegramBaseTest.Tests
             {
                 case "reply":
 
-                    
 
                     break;
 
@@ -47,10 +51,10 @@ namespace TelegramBaseTest.Tests
 
                 default:
 
-                    if (message.RawMessageData == null)
+                    if (message.UpdateData == null)
                         return;
 
-                    this.LastMessage = message.RawMessageData.Message.Text;
+                    this.LastMessage = message.Message.Text;
 
                     break;
             }

TelegramBotBase.Test/Tests/TestForm2.cs

@@ -8,25 +8,34 @@ using System.Threading.Tasks;
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.ReplyMarkups;
 using TelegramBotBase.Base;
+using TelegramBotBase.Extensions.Images;
 using TelegramBotBase.Form;
 
-namespace TelegramBaseTest.Tests
+namespace TelegramBotBaseTest.Tests
 {
     public class TestForm2 : FormBase
     {
 
 
-        public override async Task Opened()
+        public TestForm2()
+        {
+            this.Opened += TestForm2_Opened;
+            this.Closed += TestForm2_Closed;
+        }
+
+        private async Task TestForm2_Opened(object sender, EventArgs e)
         {
             await this.Device.Send("Welcome to Form 2");
         }
 
-        public override async Task Closed()
+        private async Task TestForm2_Closed(object sender, EventArgs e)
         {
             await this.Device.Send("Ciao from Form 2");
         }
 
 
+
+
         public override async Task Action(MessageResult message)
         {
             var call = message.GetData<CallbackData>();
@@ -35,6 +44,8 @@ namespace TelegramBaseTest.Tests
 
             await message.DeleteMessage();
 
+            message.Handled = true;
+
             if (call.Value == "testform1")
             {
 
@@ -44,39 +55,40 @@ namespace TelegramBaseTest.Tests
             }
             else if (call.Value == "alert")
             {
-                var fto = new TestForm2();
+                AlertDialog ad = new AlertDialog("This is a message", "Ok");
+
+                ad.ButtonClicked += async (s, en) =>
+                {
+                    var fto = new TestForm2();
+                    await this.NavigateTo(fto);
+                };
 
-                AlertDialog ad = new AlertDialog("This is a message", "Ok", fto);
-                
                 await this.NavigateTo(ad);
             }
-            else if (call.Value == "prompt")
+            else if (call.Value == "confirm")
             {
-                PromptDialog pd = new PromptDialog("Please confirm");
-
-                pd.AddButton(new ButtonBase("Ok", "ok"));
-                pd.AddButton(new ButtonBase("Cancel", "cancel"));
-
-                var tf = new TestForm2();
-
-                pd.ButtonForms.Add("ok", tf);
-                pd.ButtonForms.Add("cancel", tf);
-               
-                await this.NavigateTo(pd);
-            }
-            else if (call.Value == "promptevt")
-            {
-                PromptDialog pd = new PromptDialog("Please confirm", new ButtonBase("Ok", "ok"), new ButtonBase("Cancel", "cancel"));
+                ConfirmDialog pd = new ConfirmDialog("Please confirm", new ButtonBase("Ok", "ok"), new ButtonBase("Cancel", "cancel"));
 
                 pd.ButtonClicked += async (s, en) =>
                 {
                     var tf = new TestForm2();
-                    
+
                     await pd.NavigateTo(tf);
                 };
 
                 await this.NavigateTo(pd);
             }
+            else if (call.Value == "prompt")
+            {
+                PromptDialog pd = new PromptDialog("Please tell me your name ?");
+
+                pd.Completed += async (s, en) =>
+                {
+                    await this.Device.Send("Hello " + pd.Value);
+                };
+
+                await this.OpenModal(pd);
+            }
 
 
         }
@@ -102,12 +114,12 @@ namespace TelegramBaseTest.Tests
 
             btn.AddButtonRow(new ButtonBase("Information Prompt", CallbackData.Create("navigate", "alert")));
 
-            btn.AddButtonRow(new ButtonBase("Confirmation Prompt without event", CallbackData.Create("navigate", "prompt")));
+            btn.AddButtonRow(new ButtonBase("Confirmation Prompt with event", CallbackData.Create("navigate", "confirm")));
 
-            btn.AddButtonRow(new ButtonBase("Confirmation Prompt with event", CallbackData.Create("navigate", "promptevt")));
+            btn.AddButtonRow(new ButtonBase("Request Prompt", CallbackData.Create("navigate", "prompt")));
 
 
-            await this.Device.SendPhoto(bmp, "Test", btn);
+            await this.Device.SendPhoto(bmp, "Test", "", btn);
 
         }
 

TelegramBotBase.Test/packages.config

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

TelegramBotBase/Args/BotCommandEventArgs.cs

@@ -6,12 +6,12 @@ using System.Threading.Tasks;
 using Telegram.Bot.Types;
 using TelegramBotBase.Sessions;
 
-namespace TelegramBotBase.Base
+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.Base
         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

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TelegramBotBase.Controls.Hybrid;
+using TelegramBotBase.Form;
+
+namespace TelegramBotBase.Args
+{
+    /// <summary>
+    /// Button get clicked event
+    /// </summary>
+    public class ButtonClickedEventArgs : EventArgs
+    {
+        public ButtonBase Button { get; set; }
+
+        public int Index { get; set; }
+
+        public object Tag { get; set; }
+
+        public ButtonRow Row { get; set; }
+
+
+        public ButtonClickedEventArgs()
+        {
+
+        }
+
+        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/GroupChangedEventArgs.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Telegram.Bot.Types.Enums;
+using TelegramBotBase.Base;
+
+namespace TelegramBotBase.Args
+{
+    public class GroupChangedEventArgs : EventArgs
+    {
+        public MessageType Type { get; set; }
+
+        public MessageResult OriginalMessage { get; set; }
+
+        public GroupChangedEventArgs(MessageType type, MessageResult message)
+        {
+            this.Type = type;
+            this.OriginalMessage = message;
+        }
+
+
+
+    }
+}

TelegramBotBase/Args/InitEventArgs.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TelegramBotBase.Args
+{
+    public class InitEventArgs : EventArgs
+    {
+        public object[] Args { get; set; }
+
+        public InitEventArgs(params object[] args)
+        {
+            this.Args = args;
+        }
+    }
+}

TelegramBotBase/Args/LoadStateEventArgs.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TelegramBotBase.Args
+{
+    public class LoadStateEventArgs
+    {
+        public Dictionary<String,object> Values { get; set; }
+
+        public LoadStateEventArgs()
+        {
+            Values = new Dictionary<string, object>();
+        }
+
+        public List<String> Keys
+        {
+            get
+            {
+                return Values.Keys.ToList();
+            }
+        }
+
+        public String Get(String key)
+        {
+            return Values[key].ToString();
+        }
+
+        public int GetInt(String key)
+        {
+            int i = 0;
+            if (int.TryParse(Values[key].ToString(), out i))
+                return i;
+
+            return 0;
+        }
+
+        public double GetDouble(String key)
+        {
+            double d = 0;
+            if (double.TryParse(Values[key].ToString(), out d))
+                return d;
+
+            return 0;
+        }
+
+        public bool GetBool(String key)
+        {
+            bool b = false;
+            if (bool.TryParse(Values[key].ToString(), out b))
+                return b;
+
+            return false;
+        }
+
+        public object GetObject(String key)
+        {
+            return Values[key];
+        }
+
+    }
+}

TelegramBotBase/Args/MemberChangeEventArgs.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+using TelegramBotBase.Base;
+
+namespace TelegramBotBase.Args
+{
+    public class MemberChangeEventArgs : EventArgs
+    {
+        public List<User> Members { get; set; }
+
+        public MessageType Type { get; set; }
+
+        public MessageResult Result { get; set; }
+
+        public MemberChangeEventArgs()
+        {
+            this.Members = new List<User>();
+
+        }
+
+        public MemberChangeEventArgs(MessageType type, MessageResult result, params User[] members)
+        {
+            this.Type = type;
+            this.Result = result;
+            this.Members = members.ToList();
+        }
+
+
+
+
+
+    }
+}

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/MessageIncomeEventArgs.cs

@@ -7,7 +7,7 @@ using TelegramBotBase.Sessions;
 
 namespace TelegramBotBase.Base
 {
-    public class MessageIncomeResult : EventArgs
+    public class MessageIncomeEventArgs : EventArgs
     {
 
         public long DeviceId { get; set; }
@@ -16,7 +16,7 @@ namespace TelegramBotBase.Base
 
         public MessageResult Message { get; set; }
 
-        public MessageIncomeResult(long DeviceId, DeviceSession Device, MessageResult message)
+        public MessageIncomeEventArgs(long DeviceId, DeviceSession Device, MessageResult message)
         {
             this.DeviceId = DeviceId;
             this.Device = Device;

TelegramBotBase/Args/MessageReceivedEventArgs.cs

@@ -5,7 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using Telegram.Bot.Types;
 
-namespace TelegramBotBase.Base
+namespace TelegramBotBase.Args
 {
     public class MessageReceivedEventArgs
     {

TelegramBotBase/Args/MessageSentEventArgs.cs

@@ -5,7 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using Telegram.Bot.Types;
 
-namespace TelegramBotBase.Base
+namespace TelegramBotBase.Args
 {
     public class MessageSentEventArgs
     {
@@ -19,9 +19,16 @@ namespace TelegramBotBase.Base
 
         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

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Args
+{
+    public class SaveStateEventArgs
+    {
+        public Dictionary<String, object> Values { get; set; }
+
+        public SaveStateEventArgs()
+        {
+            Values = new Dictionary<string, object>();
+        }
+
+        public void Set(String key, String value)
+        {
+            Values[key] = value;
+        }
+
+        public void SetInt(String key, int value)
+        {
+            Values[key] = value;
+        }
+
+        public void SetBool(String key, bool value)
+        {
+            Values[key] = value;
+        }
+
+        public void SetDouble(String key, double value)
+        {
+            Values[key] = value;
+        }
+        public void SetObject(String key, object value)
+        {
+            Values[key] = value;
+        }
+
+    }
+}

TelegramBotBase/Args/SaveStatesEventArgs.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TelegramBotBase.Base;
+using TelegramBotBase.Sessions;
+
+namespace TelegramBotBase.Args
+{
+    public class SaveStatesEventArgs
+    {
+        public StateContainer States { get; set; }
+
+
+        public SaveStatesEventArgs(StateContainer states)
+        {
+            this.States = states;
+        }
+    }
+}

TelegramBotBase/Args/SessionBeginEventArgs.cs

@@ -7,13 +7,13 @@ using TelegramBotBase.Sessions;
 
 namespace TelegramBotBase.Base
 {
-    public class SessionBeginResult : EventArgs
+    public class SessionBeginEventArgs : EventArgs
     {
         public long DeviceId { get; set; }
 
         public DeviceSession Device { get; set; }
 
-        public SessionBeginResult(long DeviceId, DeviceSession Device)
+        public SessionBeginEventArgs(long DeviceId, DeviceSession Device)
         {
             this.DeviceId = DeviceId;
             this.Device = Device;

TelegramBotBase/Args/SystemExceptionEventArgs.cs

@@ -5,7 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using TelegramBotBase.Sessions;
 
-namespace TelegramBotBase.Base
+namespace TelegramBotBase.Args
 {
     public class SystemExceptionEventArgs : EventArgs
     {

TelegramBotBase/Args/UnhandledCallEventArgs.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 using Telegram.Bot.Types;
 using TelegramBotBase.Sessions;
 
-namespace TelegramBotBase.Base
+namespace TelegramBotBase.Args
 {
     public class UnhandledCallEventArgs : EventArgs
     {

TelegramBotBase/Attributes/IgnoreState.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Attributes
+{
+
+    /// <summary>
+    /// Declares that this class should not be getting serialized
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class IgnoreState : Attribute
+    {
+
+
+    }
+}

TelegramBotBase/Attributes/SaveState.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TelegramBotBase.Attributes
+{
+    /// <summary>
+    /// Declares that the field or property should be save and recovered an restart.
+    /// </summary>
+    public class SaveState : Attribute
+    {
+        public String Key { get; set; }
+
+    }
+}

TelegramBotBase/Base/Async.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TelegramBotBase.Base
+{
+    public static class Async
+    {
+        public delegate Task AsyncEventHandler<TEventArgs>(object sender, TEventArgs e) where TEventArgs : EventArgs;
+
+        public static IEnumerable<AsyncEventHandler<TEventArgs>> GetHandlers<TEventArgs>(
+        this AsyncEventHandler<TEventArgs> handler)
+        where TEventArgs : EventArgs
+        => handler.GetInvocationList().Cast<AsyncEventHandler<TEventArgs>>();
+
+        public static Task InvokeAllAsync<TEventArgs>(this AsyncEventHandler<TEventArgs> handler, object sender, TEventArgs e)
+         where TEventArgs : EventArgs
+         => Task.WhenAll(
+             handler.GetHandlers()
+             .Select(handleAsync => handleAsync(sender, e)));
+
+    }
+}

TelegramBotBase/Base/ButtonClickedEventArgs.cs

@@ -1,29 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using TelegramBotBase.Form;
-
-namespace TelegramBotBase.Base
-{
-    /// <summary>
-    /// Button get clicked event
-    /// </summary>
-    public class ButtonClickedEventArgs : EventArgs
-    {
-        public ButtonBase Button { get; set; }
-
-
-        public ButtonClickedEventArgs()
-        {
-
-        }
-
-        public ButtonClickedEventArgs(ButtonBase button)
-        {
-            this.Button = button;
-        }
-
-    }
-}

TelegramBotBase/Base/ControlBase.cs

@@ -13,14 +13,67 @@ namespace TelegramBotBase.Base
     {
         public Sessions.DeviceSession Device { get; set; }
 
-        public virtual async Task Render()
+        public int ID { get; set; }
+
+        public String ControlID
+        {
+            get
+            {
+                return "#c" + this.ID.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Defines if the control should be rendered and invoked with actions
+        /// </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 Cleanup()
+        public virtual async Task Load(MessageResult result)
         {
 
+
+            
+        }
+
+        public virtual async Task Action(MessageResult result, String value = null)
+        {
+
+
+            
+        }
+
+
+
+        public virtual async Task Render(MessageResult result)
+        {
+
+
+
+            
+        }
+
+        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

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Telegram.Bot;
 using Telegram.Bot.Types;
 using Telegram.Bot.Types.InputFiles;
 
@@ -13,7 +15,11 @@ namespace TelegramBotBase.Base
     /// </summary>
     public class DataResult : ResultBase
     {
-        public Telegram.Bot.Args.MessageEventArgs RawMessageData { get; set; }
+
+        //public Telegram.Bot.Args.MessageEventArgs RawMessageData { get; set; }
+
+        public UpdateResult UpdateData { get; set; }
+
 
         public Contact Contact
         {
@@ -63,11 +69,20 @@ namespace TelegramBotBase.Base
             }
         }
 
+
         public Telegram.Bot.Types.Enums.MessageType Type
         {
             get
             {
-                return this.RawMessageData?.Message?.Type ?? Telegram.Bot.Types.Enums.MessageType.Unknown;
+                return this.Message?.Type ?? Telegram.Bot.Types.Enums.MessageType.Unknown;
+            }
+        }
+
+        public override Message Message
+        {
+            get
+            {
+                return this.UpdateData?.Message;
             }
         }
 
@@ -85,45 +100,123 @@ namespace TelegramBotBase.Base
             }
         }
 
-
-        public DataResult(Telegram.Bot.Args.MessageEventArgs rawdata)
+        public DataResult(UpdateResult update)
         {
-            this.RawMessageData = rawdata;
-            this.Message = rawdata.Message;
+            this.UpdateData = update;
         }
 
-        public DataResult(MessageResult message)
-        {
-            this.RawMessageData = message.RawMessageData;
-            this.Message = message.Message;
-
-            
-        }
 
         public async Task<InputOnlineFile> DownloadDocument()
         {
-            var encryptedContent = new System.IO.MemoryStream(this.Document.FileSize);
+            var encryptedContent = new System.IO.MemoryStream(this.Document.FileSize.Value);
             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);
+            FileStream fs = new FileStream(path, FileMode.Create);
+            await this.Client.TelegramClient.DownloadFileAsync(file.FilePath, fs);
+            fs.Close();
+            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 encryptedContent = new System.IO.MemoryStream(this.Video.FileSize.Value);
             var file = await this.Client.TelegramClient.GetInfoAndDownloadFileAsync(this.Video.FileId, encryptedContent);
 
             return new InputOnlineFile(encryptedContent, "");
         }
 
+        public async Task DownloadVideo(String path)
+        {
+            var file = await this.Client.TelegramClient.GetFileAsync(this.Video.FileId);
+            FileStream fs = new FileStream(path, FileMode.Create);
+            await this.Client.TelegramClient.DownloadFileAsync(file.FilePath, fs);
+            fs.Close();
+            fs.Dispose();
+        }
+
+        public async Task<InputOnlineFile> DownloadAudio()
+        {
+            var encryptedContent = new System.IO.MemoryStream(this.Audio.FileSize.Value);
+            var file = await this.Client.TelegramClient.GetInfoAndDownloadFileAsync(this.Audio.FileId, encryptedContent);
+
+            return new InputOnlineFile(encryptedContent, "");
+        }
+
+        public async Task DownloadAudio(String path)
+        {
+            var file = await this.Client.TelegramClient.GetFileAsync(this.Audio.FileId);
+            FileStream fs = new FileStream(path, FileMode.Create);
+            await this.Client.TelegramClient.DownloadFileAsync(file.FilePath, fs);
+            fs.Close();
+            fs.Dispose();
+        }
+
         public async Task<InputOnlineFile> DownloadPhoto(int index)
         {
             var photo = this.Photos[index];
-            var encryptedContent = new System.IO.MemoryStream(photo.FileSize);
+            var encryptedContent = new System.IO.MemoryStream(photo.FileSize.Value);
             var file = await this.Client.TelegramClient.GetInfoAndDownloadFileAsync(photo.FileId, encryptedContent);
-            
+
             return new InputOnlineFile(encryptedContent, "");
         }
 
+        public async Task DownloadPhoto(int index, String path)
+        {
+            var photo = this.Photos[index];
+            var file = await this.Client.TelegramClient.GetFileAsync(photo.FileId);
+            FileStream fs = new FileStream(path, FileMode.Create);
+            await this.Client.TelegramClient.DownloadFileAsync(file.FilePath, fs);
+            fs.Close();
+            fs.Dispose();
+        }
+
     }
 }

TelegramBotBase/Base/FormBase.cs

@@ -1,10 +1,14 @@
 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;
+using TelegramBotBase.Form.Navigation;
 using TelegramBotBase.Sessions;
+using static TelegramBotBase.Base.Async;
 
 namespace TelegramBotBase.Form
 {
@@ -13,12 +17,13 @@ namespace TelegramBotBase.Form
     /// </summary>
     public class FormBase : IDisposable
     {
+
+        public NavigationController NavigationController { get; set; }
+
         public DeviceSession Device { get; set; }
 
         public MessageClient Client { get; set; }
 
-        public bool CustomEventManagement { get; set; } = false;
-
         /// <summary>
         /// has this formular already been disposed ?
         /// </summary>
@@ -26,38 +31,145 @@ namespace TelegramBotBase.Form
 
         public List<ControlBase> Controls { get; set; }
 
+
+        public EventHandlerList Events = new EventHandlerList();
+
+
+        private static object __evInit = new object();
+
+        private static object __evOpened = new object();
+
+        private static object __evClosed = new object();
+
+
         public FormBase()
         {
             this.Controls = new List<Base.ControlBase>();
         }
 
-        public FormBase(MessageClient Client): this()
+        public FormBase(MessageClient Client) : this()
         {
             this.Client = Client;
         }
 
-        /// <summary>
-        /// Will get called at the initialization (once per context)
-        /// </summary>
-        public virtual async Task Init(params object[] args)
+
+        public async Task OnInit(InitEventArgs e)
         {
-            
+            if (this.Events[__evInit] == null)
+                return;
+
+            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);
+            }
+        }
+
+        ///// <summary>
+        ///// Will get called at the initialization (once per context)
+        ///// </summary>
+        public event AsyncEventHandler<InitEventArgs> Init
+        {
+            add
+            {
+                this.Events.AddHandler(__evInit, value);
+            }
+            remove
+            {
+                this.Events.RemoveHandler(__evInit, value);
+            }
+        }
+
+
+
+        public async Task OnOpened(EventArgs e)
+        {
+            if (this.Events[__evOpened] == null)
+                return;
+
+            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);
+            }
         }
 
         /// <summary>
         /// Gets invoked if gets navigated to this form
         /// </summary>
         /// <returns></returns>
-        public virtual async Task Opened()
+        public event AsyncEventHandler<EventArgs> Opened
+        {
+            add
+            {
+                this.Events.AddHandler(__evOpened, value);
+            }
+            remove
+            {
+                this.Events.RemoveHandler(__evOpened, value);
+            }
+        }
+
+        
+
+        public async Task OnClosed(EventArgs e)
+        {
+            if (this.Events[__evClosed] == null)
+                return;
+
+            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);
+            }
+        }
+
+
+        /// <summary>
+        /// Form has been closed (left)
+        /// </summary>
+        /// <returns></returns>
+        public event AsyncEventHandler<EventArgs> Closed
+        {
+            add
+            {
+                this.Events.AddHandler(__evClosed, value);
+            }
+            remove
+            {
+                this.Events.RemoveHandler(__evClosed, value);
+            }
+        }
+
+        /// <summary>
+        /// Get invoked when a modal child from has been closed.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public virtual async Task ReturnFromModal(ModalDialog modal)
         {
 
         }
 
-        public virtual async Task Closed()
+
+        /// <summary>
+        /// Pre to form close, cleanup all controls
+        /// </summary>
+        /// <returns></returns>
+        public async Task CloseControls()
         {
             foreach (var b in this.Controls)
             {
-                await b.Cleanup();
+                b.Cleanup().Wait();
             }
         }
 
@@ -66,6 +178,33 @@ namespace TelegramBotBase.Form
 
         }
 
+        /// <summary>
+        /// Gets invoked if a message was sent or an action triggered
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        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)
+            {
+                var c = this.Controls.FirstOrDefault(a => a.ControlID == message.RawData.Split('_')[0]);
+                if (c != null)
+                {
+                    await c.Load(message);
+                    return;
+                }
+            }
+
+            foreach (var b in this.Controls)
+            {
+                if (!b.Enabled)
+                    continue;
+
+                await b.Load(message);
+            }
+        }
+
         /// <summary>
         /// Gets invoked if the form gets loaded and on every message belongs to this context
         /// </summary>
@@ -76,6 +215,47 @@ namespace TelegramBotBase.Form
 
         }
 
+        /// <summary>
+        /// Gets invoked, when a messages has been edited.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public virtual async Task Edited(MessageResult message)
+        {
+
+        }
+
+
+        /// <summary>
+        /// Gets invoked if the user clicked a button.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        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"))
+            {
+                var c = this.Controls.FirstOrDefault(a => a.ControlID == message.RawData.Split('_')[0]);
+                if (c != null)
+                {
+                    await c.Action(message, message.RawData.Split('_')[1]);
+                    return;
+                }
+            }
+
+            foreach (var b in this.Controls)
+            {
+                if (!b.Enabled)
+                    continue;
+
+                await b.Action(message);
+
+                if (message.Handled)
+                    return;
+            }
+        }
+
         /// <summary>
         /// Gets invoked if the user has clicked a button.
         /// </summary>
@@ -96,6 +276,22 @@ namespace TelegramBotBase.Form
 
         }
 
+        /// <summary>
+        /// Gets invoked at the end of the cycle to "Render" text, images, buttons, etc...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public virtual async Task RenderControls(MessageResult message)
+        {
+            foreach (var b in this.Controls)
+            {
+                if (!b.Enabled)
+                    continue;
+
+                await b.Render(message);
+            }
+        }
+
         /// <summary>
         /// Gets invoked at the end of the cycle to "Render" text, images, buttons, etc...
         /// </summary>
@@ -106,12 +302,14 @@ namespace TelegramBotBase.Form
 
         }
 
+
+
         /// <summary>
         /// Navigates to a new form
         /// </summary>
         /// <param name="newForm"></param>
         /// <returns></returns>
-        public async Task NavigateTo(FormBase newForm, params object[] args)
+        public virtual async Task NavigateTo(FormBase newForm, params object[] args)
         {
             DeviceSession ds = this.Device;
             if (ds == null)
@@ -119,17 +317,128 @@ namespace TelegramBotBase.Form
 
             ds.FormSwitched = true;
 
+            ds.PreviousForm = ds.ActiveForm;
+
             ds.ActiveForm = newForm;
             newForm.Client = this.Client;
             newForm.Device = ds;
 
-            ds.PreviousForm = this;
+            //Notify prior to close
+            foreach (var b in this.Controls)
+            {
+                if (!b.Enabled)
+                    continue;
 
-            await newForm.Init(args);
+                await b.Hidden(true);
+            }
 
-            await this.Closed();
+            this.CloseControls().Wait();
 
-            await newForm.Opened();
+            await this.OnClosed(new EventArgs());
+
+            await newForm.OnInit(new InitEventArgs(args));
+
+            await newForm.OnOpened(new EventArgs());
+        }
+
+        /// <summary>
+        /// Opens this form modal, but don't closes the original ones
+        /// </summary>
+        /// <param name="newForm"></param>
+        /// <returns></returns>
+        public virtual async Task OpenModal(ModalDialog newForm, params object[] args)
+        {
+            DeviceSession ds = this.Device;
+            if (ds == null)
+                return;
+
+            var parentForm = this;
+
+            ds.FormSwitched = true;
+
+            ds.PreviousForm = ds.ActiveForm;
+
+            ds.ActiveForm = newForm;
+            newForm.Client = parentForm.Client;
+            newForm.Device = ds;
+            newForm.ParentForm = parentForm;
+
+            newForm.Closed += async (s, en) =>
+            {
+                await CloseModal(newForm, parentForm);
+            };
+
+            foreach (var b in this.Controls)
+            {
+                if (!b.Enabled)
+                    continue;
+
+                await b.Hidden(false);
+            }
+
+            await newForm.OnInit(new InitEventArgs(args));
+
+            await newForm.OnOpened(new EventArgs());
+        }
+
+        public async Task CloseModal(ModalDialog modalForm, FormBase oldForm)
+        {
+            DeviceSession ds = this.Device;
+            if (ds == null)
+                return;
+
+            if (modalForm == null)
+                throw new Exception("No modal form");
+
+            ds.FormSwitched = true;
+
+            ds.PreviousForm = ds.ActiveForm;
+
+            ds.ActiveForm = oldForm;
+        }
+
+        /// <summary>
+        /// Adds a control to the formular and sets its ID and Device.
+        /// </summary>
+        /// <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>
+        /// Removes control from the formular and runs a cleanup on it.
+        /// </summary>
+        /// <param name="control"></param>
+        public void RemoveControl(ControlBase control)
+        {
+            if (!this.Controls.Contains(control))
+                return;
+
+            control.Cleanup().Wait();
+
+            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>

TelegramBotBase/Base/MessageClient.cs

@@ -5,7 +5,13 @@ using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
+using Telegram.Bot.Exceptions;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+using Telegram.Bot.Extensions.Polling;
 
 namespace TelegramBotBase.Base
 {
@@ -15,16 +21,23 @@ namespace TelegramBotBase.Base
     public class MessageClient
     {
 
+
         public String APIKey { get; set; }
 
-        public Telegram.Bot.TelegramBotClient TelegramClient { get; set; }
+        public ITelegramBotClient TelegramClient { get; set; }
 
         private EventHandlerList __Events { get; set; } = new EventHandlerList();
 
+        private static object __evOnMessageLoop = new object();
+
         private static object __evOnMessage = new object();
 
+        private static object __evOnMessageEdit = new object();
+
         private static object __evCallbackQuery = new object();
 
+        CancellationTokenSource __cancellationTokenSource;
+
 
         public MessageClient(String APIKey)
         {
@@ -38,18 +51,27 @@ namespace TelegramBotBase.Base
         {
             this.APIKey = APIKey;
             this.TelegramClient = new Telegram.Bot.TelegramBotClient(APIKey, proxy);
-           
+
 
             Prepare();
         }
 
-        public MessageClient(String APIKey, Uri proxyUrl)
+
+
+        public MessageClient(String APIKey, Uri proxyUrl, NetworkCredential credential = null)
         {
             this.APIKey = APIKey;
 
-            var proxy = new WebProxy(proxyUrl);
+            var proxy = new WebProxy(proxyUrl)
+            {
+                Credentials = credential
+            };
 
-            this.TelegramClient = new Telegram.Bot.TelegramBotClient(APIKey, proxy);
+            var httpClient = new HttpClient(
+                new HttpClientHandler { Proxy = proxy, UseProxy = true }
+            );
+
+            this.TelegramClient = new Telegram.Bot.TelegramBotClient(APIKey, httpClient);
 
             Prepare();
         }
@@ -66,11 +88,17 @@ namespace TelegramBotBase.Base
 
             var proxy = new WebProxy(proxyHost, proxyPort);
 
-            this.TelegramClient = new Telegram.Bot.TelegramBotClient(APIKey, proxy);
+            var httpClient = new HttpClient(
+                new HttpClientHandler { Proxy = proxy, UseProxy = true }
+            );
+
+            this.TelegramClient = new Telegram.Bot.TelegramBotClient(APIKey, httpClient);
 
             Prepare();
         }
 
+
+
         public MessageClient(String APIKey, Telegram.Bot.TelegramBotClient Client)
         {
             this.APIKey = APIKey;
@@ -84,80 +112,90 @@ namespace TelegramBotBase.Base
         {
             this.TelegramClient.Timeout = new TimeSpan(0, 0, 30);
 
-
-            this.TelegramClient.OnMessage += TelegramClient_OnMessage;
-            this.TelegramClient.OnCallbackQuery += TelegramClient_OnCallbackQuery;
-
         }
 
 
-        private async void TelegramClient_OnMessage(object sender, Telegram.Bot.Args.MessageEventArgs e)
+
+        public void StartReceiving()
         {
-            //Skip empty messages by default
-            if (e.Message == null)
-                return;
+            __cancellationTokenSource = new CancellationTokenSource();
 
-            try
-            {
-                var mr = new MessageResult(e);
-                mr.Client = this;
-                OnMessage(mr);
-            }
-            catch
+            var receiverOptions = new ReceiverOptions
             {
+                AllowedUpdates = { } // receive all update types
+            };
 
-            }
+            this.TelegramClient.StartReceiving(HandleUpdateAsync, HandleErrorAsync, receiverOptions, __cancellationTokenSource.Token);
         }
 
-        private async void TelegramClient_OnCallbackQuery(object sender, Telegram.Bot.Args.CallbackQueryEventArgs e)
+        public void StopReceiving()
         {
-            try
-            {
-                var ar = new MessageResult(e);
-                ar.Client = this;
-                OnAction(ar);
-            }
-            catch
-            {
-
-            }
+            __cancellationTokenSource.Cancel();
         }
 
 
+        public Task HandleUpdateAsync(ITelegramBotClient botClient, Update update, CancellationToken cancellationToken)
+        {
+            OnMessageLoop(new UpdateResult(update, null));
+
+            return Task.CompletedTask;
+        }
+
+        public Task HandleErrorAsync(ITelegramBotClient botClient, Exception exception, CancellationToken cancellationToken)
+        {
+            if (exception is ApiRequestException exAPI)
+            {
+                Console.WriteLine($"Telegram API Error:\n[{exAPI.ErrorCode}]\n{exAPI.Message}");
+            }
+            else
+            {
+                Console.WriteLine(exception.ToString());
+            }
+            return Task.CompletedTask;
+        }
+
+
+        /// <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"
 
-        public event EventHandler<MessageResult> Message
+        
+
+        public event Async.AsyncEventHandler<UpdateResult> MessageLoop
         {
             add
             {
-                this.__Events.AddHandler(__evOnMessage, value);
+                this.__Events.AddHandler(__evOnMessageLoop, value);
             }
             remove
             {
-                this.__Events.RemoveHandler(__evOnMessage, value);
+                this.__Events.RemoveHandler(__evOnMessageLoop, value);
             }
         }
 
-        public void OnMessage(MessageResult result)
+        public void OnMessageLoop(UpdateResult update)
         {
-            (this.__Events[__evOnMessage] as EventHandler<MessageResult>)?.Invoke(this, result);
-        }
-
-        public event EventHandler<MessageResult> Action
-        {
-            add
-            {
-                this.__Events.AddHandler(__evCallbackQuery, value);
-            }
-            remove
-            {
-                this.__Events.RemoveHandler(__evCallbackQuery, value);
-            }
-        }
-
-        public void OnAction(MessageResult result)
-        {
-            (this.__Events[__evCallbackQuery] as EventHandler<MessageResult>)?.Invoke(this, result);
+            (this.__Events[__evOnMessageLoop] as Async.AsyncEventHandler<UpdateResult>)?.Invoke(this, update);
         }
 
 

TelegramBotBase/Base/MessageResult.cs

@@ -3,15 +3,16 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Telegram.Bot;
+using Telegram.Bot.Types;
 using TelegramBotBase.Sessions;
 
 namespace TelegramBotBase.Base
 {
     public class MessageResult : ResultBase
     {
-        public Telegram.Bot.Args.MessageEventArgs RawMessageData { get; set; }
 
-        public Telegram.Bot.Args.CallbackQueryEventArgs RawCallbackData { get; set; }
+        public Telegram.Bot.Types.Update UpdateData { get; set; }
 
         /// <summary>
         /// Returns the Device/ChatId
@@ -20,12 +21,19 @@ namespace TelegramBotBase.Base
         {
             get
             {
-                return this.RawMessageData?.Message?.Chat.Id ?? this.RawCallbackData?.CallbackQuery.Message?.Chat.Id ?? 0;
+                return this.UpdateData?.Message?.Chat?.Id
+                    ?? this.UpdateData?.EditedMessage?.Chat.Id
+                    ?? this.UpdateData?.CallbackQuery.Message?.Chat.Id
+                    ?? Device?.DeviceId
+                    ?? 0;
             }
         }
 
         public DeviceSession Device
-        { get; set; }
+        {
+            get;
+            set;
+        }
 
         /// <summary>
         /// The message id
@@ -34,7 +42,10 @@ namespace TelegramBotBase.Base
         {
             get
             {
-                return this.Message?.MessageId ?? this.RawCallbackData?.CallbackQuery?.Message?.MessageId ?? 0;
+                return this.UpdateData?.Message?.MessageId
+                    ?? this.Message?.MessageId
+                    ?? this.UpdateData?.CallbackQuery?.Message?.MessageId
+                    ?? 0;
             }
         }
 
@@ -42,7 +53,7 @@ namespace TelegramBotBase.Base
         {
             get
             {
-                return this.RawMessageData?.Message?.Text ?? "";
+                return this.UpdateData?.Message?.Text ?? "";
             }
         }
 
@@ -50,7 +61,27 @@ namespace TelegramBotBase.Base
         {
             get
             {
-                return this.RawMessageData?.Message?.Text ?? "";
+                return this.UpdateData?.Message?.Text ?? "";
+            }
+        }
+
+        public Telegram.Bot.Types.Enums.MessageType MessageType
+        {
+            get
+            {
+                return Message?.Type ?? Telegram.Bot.Types.Enums.MessageType.Unknown;
+            }
+        }
+
+        public Message Message
+        {
+            get
+            {
+                return this.UpdateData?.Message
+                    ?? this.UpdateData?.EditedMessage
+                    ?? this.UpdateData?.ChannelPost
+                    ?? this.UpdateData?.EditedChannelPost
+                    ?? this.UpdateData?.CallbackQuery?.Message;
             }
         }
 
@@ -61,14 +92,14 @@ namespace TelegramBotBase.Base
         {
             get
             {
-                return (this.RawCallbackData != null);
+                return (this.UpdateData.CallbackQuery != null);
             }
         }
 
         /// <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
             {
@@ -79,11 +110,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
@@ -92,26 +123,31 @@ 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];
             }
         }
 
+        /// <summary>
+        /// Returns if this message will be used on the first form or not.
+        /// </summary>
+        public bool IsFirstHandler { get; set; } = true;
+
         public bool Handled { get; set; } = false;
 
         public String RawData
         {
             get
             {
-                return this.RawCallbackData?.CallbackQuery?.Data;
+                return this.UpdateData?.CallbackQuery?.Data;
             }
         }
 
@@ -138,16 +174,9 @@ 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);
-            }
-            catch
-            {
-
-            }
+            await this.Device.ConfirmAction(this.UpdateData.CallbackQuery.Id, message, showAlert, urlToOpen);
         }
 
         public override async Task DeleteMessage()
@@ -162,17 +191,15 @@ namespace TelegramBotBase.Base
             }
         }
 
-
-        public MessageResult(Telegram.Bot.Args.MessageEventArgs rawdata)
+        internal MessageResult()
         {
-            this.RawMessageData = rawdata;
-            this.Message = rawdata.Message;
+
         }
 
-        public MessageResult(Telegram.Bot.Args.CallbackQueryEventArgs callback)
+        public MessageResult(Telegram.Bot.Types.Update update)
         {
-            this.RawCallbackData = callback;
-            this.Message = callback.CallbackQuery.Message;
+            this.UpdateData = update;
+
         }
 
     }

TelegramBotBase/Base/ResultBase.cs

@@ -3,10 +3,11 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Telegram.Bot;
 
 namespace TelegramBotBase.Base
 {
-    public class ResultBase
+    public class ResultBase : EventArgs
     {
         public MessageClient Client { get; set; }
 
@@ -20,7 +21,7 @@ namespace TelegramBotBase.Base
             }
         }
 
-        public Telegram.Bot.Types.Message Message { get; set; }
+        public virtual Telegram.Bot.Types.Message Message { get; set; }
 
         /// <summary>
         /// Deletes the current message

TelegramBotBase/Base/StateContainer.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TelegramBotBase.Base
+{
+    public partial class StateContainer
+    {
+        public List<StateEntry> States { get; set; }
+
+        public List<long> ChatIds
+        {
+            get
+            {
+                return States.Where(a => a.DeviceId > 0).Select(a => a.DeviceId).ToList();
+            }
+        }
+
+        public List<long> GroupIds
+        {
+            get
+            {
+                return States.Where(a => a.DeviceId < 0).Select(a => a.DeviceId).ToList();
+            }
+        }
+
+        public StateContainer()
+        {
+            this.States = new List<StateEntry>();
+        }
+
+    }
+}

TelegramBotBase/Base/StateEntry.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace TelegramBotBase.Base
+{
+    
+    [DebuggerDisplay("Device: {DeviceId}, {FormUri}")]
+    public class StateEntry
+    {
+        /// <summary>
+        /// Contains the DeviceId of the entry.
+        /// </summary>
+        public long DeviceId { get; set; }
+
+        /// <summary>
+        /// Contains the Username (on privat chats) or Group title on groups/channels.
+        /// </summary>
+        public String ChatTitle { get; set; }
+
+        /// <summary>
+        /// Contains additional values to save.
+        /// </summary>
+        public Dictionary<String, object> Values { get; set; }
+
+        /// <summary>
+        /// Contains the full qualified namespace of the form to used for reload it via reflection.
+        /// </summary>
+        public String FormUri {get;set;}
+
+        /// <summary>
+        /// Contains the assembly, where to find that form.
+        /// </summary>
+        public String QualifiedName { get; set; }
+
+        public StateEntry()
+        {
+            this.Values = new Dictionary<string, object>();
+        }
+
+    }
+}

TelegramBotBase/Base/UpdateResult.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Telegram.Bot.Types;
+using TelegramBotBase.Sessions;
+
+namespace TelegramBotBase.Base
+{
+    public class UpdateResult : ResultBase
+    {
+        public UpdateResult(Update rawData, DeviceSession device)
+        {
+            RawData = rawData;
+            Device = device;
+
+            
+        }
+
+        /// <summary>
+        /// Returns the Device/ChatId
+        /// </summary>
+        public override long DeviceId
+        {
+            get
+            {
+                return this.RawData?.Message?.Chat?.Id
+                    ?? this.RawData?.CallbackQuery?.Message?.Chat?.Id
+                    ?? Device?.DeviceId
+                    ?? 0;
+            }
+        }
+
+        public Update RawData { get; set; }
+
+        public override Message Message
+        {
+            get
+            {
+                return RawData?.Message
+                    ?? RawData?.EditedMessage
+                    ?? RawData?.ChannelPost
+                    ?? RawData?.EditedChannelPost
+                    ?? RawData?.CallbackQuery?.Message;
+            }
+        }
+        
+
+
+        public DeviceSession Device
+        {
+            get;
+            set;
+        }
+
+
+    }
+
+}

TelegramBotBase/BotBase.cs

@@ -3,10 +3,19 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Telegram.Bot;
+using Telegram.Bot.Exceptions;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+using TelegramBotBase.Args;
+using TelegramBotBase.Attributes;
 using TelegramBotBase.Base;
+using TelegramBotBase.Enums;
+using TelegramBotBase.Factories.MessageLoops;
 using TelegramBotBase.Form;
+using TelegramBotBase.Interfaces;
 using TelegramBotBase.Sessions;
 
 namespace TelegramBotBase
@@ -15,8 +24,7 @@ namespace TelegramBotBase
     /// Bot base class for full Device/Context and Messagehandling
     /// </summary>
     /// <typeparam name="T"></typeparam>
-    public class BotBase<T>
-        where T : FormBase
+    public class BotBase
     {
         public MessageClient Client { get; set; }
 
@@ -33,7 +41,10 @@ namespace TelegramBotBase
         /// <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();
 
@@ -43,114 +54,52 @@ 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)
+        /// Enable the SessionState (you need to implement on call forms the IStateForm interface)
         /// </summary>
-        public bool SkipAllMessages { get; set; } = false;
+        public IStateMachine StateMachine { get; set; }
 
         /// <summary>
-        /// Loggs all messages and sent them to the event handler
+        /// Offers functionality to manage the creation process of the start form.
         /// </summary>
-        public bool LogAllMessages { get; set; } = false;
+        public IStartFormFactory StartFormFactory { get; set; }
 
         /// <summary>
-        /// How often could a form navigate to another (within one user action/call/message)
+        /// Contains the message loop factory, which cares about "message-management."
         /// </summary>
-        private const int NavigationMaximum = 10;
+        public IMessageLoopFactory MessageLoopFactory { get; set; }
 
         /// <summary>
-        /// Simple start of your Bot with the APIKey
+        /// All internal used settings.
         /// </summary>
-        /// <param name="apiKey"></param>
-        public BotBase(String apiKey)
+        public Dictionary<eSettings, uint> SystemSettings { get; private set; }
+
+        public BotBase()
         {
-            this.APIKey = apiKey;
+            this.SystemSettings = new Dictionary<eSettings, uint>();
 
-            this.Client = new Base.MessageClient(this.APIKey);
+            SetSetting(eSettings.MaxNumberOfRetries, 5);
+            SetSetting(eSettings.NavigationMaximum, 10);
+            SetSetting(eSettings.LogAllMessages, false);
+            SetSetting(eSettings.SkipAllMessages, false);
+            SetSetting(eSettings.SaveSessionsOnConsoleExit, false);
 
-            this.SystemCalls = new List<string>();
+            this.BotCommands = new List<BotCommand>();
 
             this.Sessions = new SessionBase();
-            this.Sessions.Client = this.Client;
+            this.Sessions.BotBase = this;
         }
 
-        /// <summary>
-        /// Simple start of your Bot with the APIKey and a proxyAdress
-        /// </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)
-        {
-            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;
-        }
-
-        /// <summary>
-        /// Simple start of your Bot with the APIKey and a TelegramBotClient instance.
-        /// </summary>
-        /// <param name="apiKey"></param>
-        /// <param name="client"></param>
-        public BotBase(String apiKey, TelegramBotClient client)
-        {
-            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;
-        }
-
-        /// <summary>
-        /// Simple start of your Bot with the APIKey and a proxyAdress
-        /// </summary>
-        /// <param name="apiKey"></param>
-        /// <param name="proxyBaseAddress">i.e. https://127.0.0.1:10000</param>
-        public BotBase(String apiKey, String proxyBaseAddress)
-        {
-            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;
-        }
-
-        /// <summary>
-        /// Simple start of your Bot with the APIKey and a proxyAdress
-        /// </summary>
-        /// <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)
-        {
-            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;
-        }
 
         /// <summary>
         /// Start your Bot
@@ -160,13 +109,61 @@ namespace TelegramBotBase
             if (this.Client == null)
                 return;
 
-            this.Client.Message += Client_Message;
-            this.Client.Action += Client_Action;
+            this.Client.MessageLoop += Client_MessageLoop;
 
 
-            this.Client.TelegramClient.StartReceiving();
+            if (this.StateMachine != null)
+            {
+                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.StartReceiving();
         }
 
+
+        private async Task Client_MessageLoop(object sender, UpdateResult e)
+        {
+            DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
+            if (ds == null)
+            {
+                ds = this.Sessions.StartSession(e.DeviceId).GetAwaiter().GetResult();
+                e.Device = ds;
+                ds.LastMessage = e.RawData.Message;
+
+                OnSessionBegins(new SessionBeginEventArgs(e.DeviceId, ds));
+            }
+
+            var mr = new MessageResult(e.RawData);
+
+            int i = 0;
+
+            //Should formulars get navigated (allow maximum of 10, to dont get loops)
+            do
+            {
+                i++;
+
+                //Reset navigation
+                ds.FormSwitched = false;
+
+                await MessageLoopFactory.MessageLoop(this, ds, e, mr);
+
+                mr.IsFirstHandler = false;
+
+            } while (ds.FormSwitched && i < this.GetSetting(eSettings.NavigationMaximum, 10));
+        }
+
+
         /// <summary>
         /// Stop your Bot
         /// </summary>
@@ -175,7 +172,12 @@ namespace TelegramBotBase
             if (this.Client == null)
                 return;
 
-            this.Client.TelegramClient.StopReceiving();
+            this.Client.MessageLoop -= Client_MessageLoop;
+
+
+            this.Client.StopReceiving();
+
+            this.Sessions.SaveSessionStates();
         }
 
         /// <summary>
@@ -194,197 +196,115 @@ namespace TelegramBotBase
             }
         }
 
-        private void Client_Message(object sender, MessageResult e)
+
+
+        /// <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)
         {
-            if (this.SkipAllMessages)
-                return;
+            var mr = new MessageResult();
 
-            try
-            {
-                DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
-                e.Device = ds;
-
-                if (LogAllMessages)
-                {
-                    OnMessage(new MessageIncomeResult(e.DeviceId, ds, e));
-                }
-
-                ds?.OnMessageReceived(new MessageReceivedEventArgs(e.Message));
-
-                Client_TryMessage(sender, e);
-            }
-            catch (Telegram.Bot.Exceptions.ApiRequestException ex)
-            {
-
-            }
-            catch (Exception ex)
-            {
-                DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
-                OnException(new SystemExceptionEventArgs(e.Message.Text, ds?.DeviceId ?? -1, ds, ex));
-            }
+            await InvokeMessageLoop(DeviceId, mr);
         }
 
-        private async void 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 SessionBeginResult(e.DeviceId, ds));
-            }
-
-            ds.LastAction = DateTime.Now;
-            ds.LastMessage = e.Message;
-
-            //Is this a systemcall ?
-            if (e.IsSystemCall && this.SystemCalls.Contains(e.SystemCommand))
-            {
-                var sce = new SystemCallEventArgs(e.SystemCommand, e.SystemCallParameters, e.Message, ds.DeviceId, ds);
-                await OnSystemCall(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;
-
-                //If the form manages the events by itselfs, skip here
-                if (activeForm.CustomEventManagement)
-                    return;
-
-                //Pre Loading Event
-                await activeForm.PreLoad(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.Render(e);
-
-            } while (ds.FormSwitched && i < NavigationMaximum);
-
-        }
-
-        private void Client_Action(object sender, MessageResult e)
+        /// <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(e.DeviceId);
+                DeviceSession ds = this.Sessions.GetSession(DeviceId);
                 e.Device = ds;
 
-                if (LogAllMessages)
-                {
-                    OnMessage(new MessageIncomeResult(e.DeviceId, ds, e));
-                }
-
-                Client_TryAction(sender, e);
+                await MessageLoopFactory.MessageLoop(this, ds, new UpdateResult(e.UpdateData, ds), e);
+                //await Client_Loop(this, e);
             }
             catch (Exception ex)
             {
-                DeviceSession ds = this.Sessions.GetSession(e.DeviceId);
-                OnException(new SystemExceptionEventArgs(e.Message.Text, ds?.DeviceId ?? -1, ds, ex));
+                DeviceSession ds = this.Sessions.GetSession(DeviceId);
+                OnException(new SystemExceptionEventArgs(e.Message.Text, DeviceId, ds, ex));
             }
         }
 
-        private async void Client_TryAction(object sender, MessageResult e)
+
+        /// <summary>
+        /// Will get invoke on an unhandled call.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        public void MessageLoopFactory_UnhandledCall(object sender, UnhandledCallEventArgs 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;
-
-                //If the form manages the events by itselfs, skip here
-                if (activeForm.CustomEventManagement)
-                    return;
-
-                //Pre Loading Event
-                await activeForm.PreLoad(e);
-
-                //Loading Event
-                await activeForm.Load(e);
-
-                //Action Event
-                if (!ds.FormSwitched)
-                {
-                    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.Render(e);
-
-            } while (ds.FormSwitched && i < NavigationMaximum);
-
+            OnUnhandledCall(e);
         }
 
+        /// <summary>
+        /// This method will update all local created bot commands to the botfather.
+        /// </summary>
+        public async Task UploadBotCommands()
+        {
+            await this.Client.SetBotCommands(this.BotCommands);
+        }
+
+        /// <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>
 
-        public event EventHandler<SessionBeginResult> SessionBegins
+        public event EventHandler<SessionBeginEventArgs> SessionBegins
         {
             add
             {
@@ -396,16 +316,16 @@ namespace TelegramBotBase
             }
         }
 
-        public void OnSessionBegins(SessionBeginResult e)
+        public void OnSessionBegins(SessionBeginEventArgs e)
         {
-            (this.__Events[__evSessionBegins] as EventHandler<SessionBeginResult>)?.Invoke(this, e);
+            (this.__Events[__evSessionBegins] as EventHandler<SessionBeginEventArgs>)?.Invoke(this, e);
 
         }
 
         /// <summary>
         /// Will be called on incomming message
         /// </summary>
-        public event EventHandler<MessageIncomeResult> Message
+        public event EventHandler<MessageIncomeEventArgs> Message
         {
             add
             {
@@ -417,22 +337,22 @@ namespace TelegramBotBase
             }
         }
 
-        public void OnMessage(MessageIncomeResult e)
+        public void OnMessage(MessageIncomeEventArgs e)
         {
-            (this.__Events[__evMessage] as EventHandler<MessageIncomeResult>)?.Invoke(this, e);
+            (this.__Events[__evMessage] as EventHandler<MessageIncomeEventArgs>)?.Invoke(this, e);
 
         }
 
         /// <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)
-                await SystemCall(this, e);
+            if (this.BotCommand != null)
+                await BotCommand(this, e);
         }
 
         /// <summary>
@@ -476,5 +396,8 @@ namespace TelegramBotBase
             (this.__Events[__evUnhandledCall] as EventHandler<UnhandledCallEventArgs>)?.Invoke(this, e);
 
         }
+
+        #endregion
+
     }
 }

TelegramBotBase/Builder/BotBaseBuilder.cs

@@ -0,0 +1,324 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using TelegramBotBase.Base;
+using TelegramBotBase.Builder.Interfaces;
+using TelegramBotBase.Commands;
+using TelegramBotBase.Form;
+using TelegramBotBase.Interfaces;
+using TelegramBotBase.Localizations;
+using TelegramBotBase.States;
+
+namespace TelegramBotBase.Builder
+{
+    public class BotBaseBuilder : IAPIKeySelectionStage, IMessageLoopSelectionStage, IStartFormSelectionStage, IBuildingStage, INetworkingSelectionStage, IBotCommandsStage, ISessionSerializationStage, ILanguageSelectionStage
+    {
+
+        String _apiKey = null;
+
+        IStartFormFactory _factory = null;
+
+        MessageClient _client = null;
+
+        List<BotCommand> _botcommands = new List<BotCommand>();
+
+        IStateMachine _statemachine = null;
+
+        IMessageLoopFactory _messageloopfactory = null;
+
+        private BotBaseBuilder()
+        {
+
+        }
+
+        public static IAPIKeySelectionStage Create()
+        {
+            return new BotBaseBuilder();
+        }
+
+        #region "Step 1 (Basic Stuff)"
+
+        public IMessageLoopSelectionStage WithAPIKey(string apiKey)
+        {
+            this._apiKey = apiKey;
+            return this;
+        }
+
+
+        public IBuildingStage QuickStart(string apiKey, Type StartForm)
+        {
+            this._apiKey = apiKey;
+            this._factory = new Factories.DefaultStartFormFactory(StartForm);
+
+            DefaultMessageLoop();
+
+            NoProxy();
+
+            OnlyStart();
+
+            NoSerialization();
+
+            DefaultLanguage();
+
+            return this;
+        }
+
+
+        public IBuildingStage QuickStart<T>(string apiKey)
+            where T : FormBase
+        {
+            this._apiKey = apiKey;
+            this._factory = new Factories.DefaultStartFormFactory(typeof(T));
+
+            DefaultMessageLoop();
+
+            NoProxy();
+
+            OnlyStart();
+
+            NoSerialization();
+
+            DefaultLanguage();
+
+            return this;
+        }
+
+        public IBuildingStage QuickStart(string apiKey, IStartFormFactory StartFormFactory)
+        {
+            this._apiKey = apiKey;
+            this._factory = StartFormFactory;
+
+            DefaultMessageLoop();
+
+            NoProxy();
+
+            OnlyStart();
+
+            NoSerialization();
+
+            DefaultLanguage();
+
+            return this;
+        }
+
+        #endregion
+
+
+        #region "Step 2 (Message Loop)"
+
+        public IStartFormSelectionStage DefaultMessageLoop()
+        {
+            _messageloopfactory = new Factories.MessageLoops.FormBaseMessageLoop();
+
+            return this;
+        }
+
+        public IStartFormSelectionStage CustomMessageLoop(IMessageLoopFactory messageLoopClass)
+        {
+            _messageloopfactory = messageLoopClass;
+
+            return this;
+        }
+
+        public IStartFormSelectionStage CustomMessageLoop<T>()
+            where T : class, new()
+        {
+            _messageloopfactory = typeof(T).GetConstructor(new Type[] { })?.Invoke(new object[] { }) as IMessageLoopFactory;
+
+            return this;
+        }
+
+        #endregion
+
+
+        #region "Step 3 (Start Form/Factory)" 
+
+        public INetworkingSelectionStage WithStartForm(Type startFormClass)
+        {
+            this._factory = new Factories.DefaultStartFormFactory(startFormClass);
+            return this;
+        }
+
+        public INetworkingSelectionStage WithStartForm<T>()
+            where T : FormBase, new()
+        {
+            this._factory = new Factories.DefaultStartFormFactory(typeof(T));
+            return this;
+        }
+
+        public INetworkingSelectionStage WithStartFormFactory(IStartFormFactory factory)
+        {
+            this._factory = factory;
+            return this;
+        }
+
+        #endregion
+
+
+        #region "Step 4 (Network Settings)"
+
+        public IBotCommandsStage WithProxy(string proxyAddress)
+        {
+            var url = new Uri(proxyAddress);
+            _client = new MessageClient(_apiKey, url);
+            _client.TelegramClient.Timeout = new TimeSpan(0, 1, 0);
+            return this;
+        }
+
+
+        public IBotCommandsStage NoProxy()
+        {
+            _client = new MessageClient(_apiKey);
+            _client.TelegramClient.Timeout = new TimeSpan(0, 1, 0);
+            return this;
+        }
+
+
+        public IBotCommandsStage WithBotClient(TelegramBotClient tgclient)
+        {
+            _client = new MessageClient(_apiKey, tgclient);
+            _client.TelegramClient.Timeout = new TimeSpan(0, 1, 0);
+            return this;
+        }
+
+
+        public IBotCommandsStage WithHostAndPort(string proxyHost, int proxyPort)
+        {
+            _client = new MessageClient(_apiKey, proxyHost, proxyPort);
+            _client.TelegramClient.Timeout = new TimeSpan(0, 1, 0);
+            return this;
+        }
+
+        public IBotCommandsStage WithHttpClient(HttpClient tgclient)
+        {
+            _client = new MessageClient(_apiKey, tgclient);
+            _client.TelegramClient.Timeout = new TimeSpan(0, 1, 0);
+            return this;
+        }
+
+
+        #endregion
+
+
+        #region "Step 5 (Bot Commands)"
+
+        public ISessionSerializationStage NoCommands()
+        {
+            return this;
+        }
+
+        public ISessionSerializationStage OnlyStart()
+        {
+            _botcommands.Start("Starts the bot");
+
+            return this;
+
+        }
+
+        public ISessionSerializationStage DefaultCommands()
+        {
+            _botcommands.Start("Starts the bot");
+            _botcommands.Help("Should show you some help");
+            _botcommands.Settings("Should show you some settings");
+            return this;
+        }
+
+        public ISessionSerializationStage CustomCommands(Action<List<BotCommand>> action)
+        {
+            action?.Invoke(_botcommands);
+            return this;
+        }
+
+        #endregion
+
+
+        #region "Step 6 (Serialization)"
+
+        public ILanguageSelectionStage NoSerialization()
+        {
+            return this;
+        }
+
+        public ILanguageSelectionStage UseSerialization(IStateMachine machine)
+        {
+            this._statemachine = machine;
+            return this;
+        }
+
+
+        public ILanguageSelectionStage UseJSON(string path)
+        {
+            this._statemachine = new JSONStateMachine(path);
+            return this;
+        }
+
+        public ILanguageSelectionStage UseSimpleJSON(string path)
+        {
+            this._statemachine = new SimpleJSONStateMachine(path);
+            return this;
+        }
+
+        public ILanguageSelectionStage UseXML(string path)
+        {
+            this._statemachine = new XMLStateMachine(path);
+            return this;
+        }
+
+        #endregion
+
+
+        #region "Step 7 (Language)"
+
+        public IBuildingStage DefaultLanguage()
+        {
+            return this;
+        }
+
+        public IBuildingStage UseEnglish()
+        {
+            Localizations.Default.Language = new Localizations.English();
+            return this;
+        }
+
+        public IBuildingStage UseGerman()
+        {
+            Localizations.Default.Language = new Localizations.German();
+            return this;
+        }
+
+        public IBuildingStage Custom(Localization language)
+        {
+            Localizations.Default.Language = language;
+            return this;
+        }
+
+        #endregion
+
+
+        public BotBase Build()
+        {
+            var bb = new BotBase();
+
+            bb.APIKey = _apiKey;
+            bb.StartFormFactory = _factory;
+
+            bb.Client = _client;
+
+            bb.Sessions.Client = bb.Client;
+
+            bb.BotCommands = _botcommands;
+
+            bb.StateMachine = _statemachine;
+
+            bb.MessageLoopFactory = _messageloopfactory;
+
+            bb.MessageLoopFactory.UnhandledCall += bb.MessageLoopFactory_UnhandledCall;
+
+            return bb;
+        }
+
+    }
+}