Added Kivy [bitmessagekivy/baseclass]

src/bitmessagekivy/baseclass/addressbook.py

@@ -0,0 +1,148 @@
+# pylint: disable=import-error, no-name-in-module
+# pylint: disable=import-outside-toplevel
+
+"""
+Kivy Addressbook Screen
+"""
+
+from kivy.clock import Clock
+from kivy.properties import (
+    ListProperty,
+    StringProperty
+)
+from kivy.uix.screenmanager import Screen
+
+from baseclass.common import toast
+from baseclass.popup import AddbookDetailPopup
+
+from kivymd.uix.button import MDRaisedButton
+from kivymd.uix.dialog import MDDialog
+from kivymd.uix.label import MDLabel
+
+from pybitmessage.get_platform import platform
+from pybitmessage import state
+from pybitmessage import kivy_state
+
+
+class AddressBook(Screen):
+    """AddressBook Screen class for kivy Ui"""
+
+    queryreturn = ListProperty()
+    has_refreshed = True
+    address_label = StringProperty()
+    address = StringProperty()
+
+    def __init__(self, *args, **kwargs):
+        """Getting AddressBook Details"""
+        super(AddressBook, self).__init__(*args, **kwargs)
+        self.addbook_popup = None
+        Clock.schedule_once(self.init_ui, 0)
+
+    def init_ui(self, dt=0):
+        """Clock Schdule for method AddressBook"""
+        # pylint: disable=too-many-function-args
+        self.loadAddresslist(None, 'All', '')
+        print(dt)
+
+    def loadAddresslist(self):
+        """Clock Schdule for method AddressBook"""
+        if kivy_state.searcing_text:
+            self.ids.scroll_y.scroll_y = 1.0
+        self.ids.tag_label.text = ''
+        if self.queryreturn:
+            pass
+        else:
+            content = MDLabel(
+                font_style='Caption',
+                theme_text_color='Primary',
+                text="No contact found!" if kivy_state.searcing_text
+                else "No contact found yet...... ",
+                halign='center',
+                size_hint_y=None,
+                valign='top')
+            self.ids.ml.add_widget(content)
+
+    def check_scroll_y(self):
+        """Load data on scroll"""
+        if self.ids.scroll_y.scroll_y <= -0.0 and self.has_refreshed:
+            self.ids.scroll_y.scroll_y = 0.06
+
+    @staticmethod
+    def refreshes(*args):
+        """Refresh the Widget"""
+        # state.navinstance.ids.sc11.ids.ml.clear_widgets()
+        # state.navinstance.ids.sc11.loadAddresslist(None, 'All', '')
+
+    # @staticmethod
+    def addBook_detail(self, address, label, instance):
+        """Addressbook details"""
+        if instance.state == 'closed':
+            instance.ids.delete_msg.disabled = True
+            if instance.open_progress == 0.0:
+                obj = AddbookDetailPopup()
+                self.address_label = obj.address_label = label
+                self.address = obj.address = address
+                width = .9 if platform == 'android' else .8
+                self.addbook_popup = MDDialog(
+                    type="custom",
+                    size_hint=(width, .25),
+                    content_cls=obj,
+                    buttons=[
+                        MDRaisedButton(
+                            text="Send message to",
+                            on_release=self.send_message_to,
+                        ),
+                        MDRaisedButton(
+                            text="Save",
+                            on_release=self.update_addbook_label,
+                        ),
+                        MDRaisedButton(
+                            text="Cancel",
+                            on_release=self.close_pop,
+                        ),
+                    ],
+                )
+                # self.addbook_popup.set_normal_height()
+                self.addbook_popup.auto_dismiss = False
+                self.addbook_popup.open()
+        else:
+            instance.ids.delete_msg.disabled = False
+
+    def delete_address(self, instance):
+        """Delete inbox mail from inbox listing"""
+        self.ids.ml.remove_widget(instance.parent.parent)
+        # if len(self.ids.ml.children) == 0:
+        if self.ids.ml.children is not None:
+            self.ids.tag_label.text = ''
+        toast('Address Deleted')
+
+    def close_pop(self):
+        """Pop is Canceled"""
+        self.addbook_popup.dismiss()
+        toast('Canceled')
+
+    def update_addbook_label(self):
+        """Updating the label of address book address"""
+        address_list = []
+        stored_labels = [labels[0] for labels in address_list]
+        add_dict = dict(address_list)
+        label = str(self.addbook_popup.content_cls.ids.add_label.text)
+        if label in stored_labels and self.address == add_dict[label]:
+            stored_labels.remove(label)
+        if label and label not in stored_labels:
+            state.kivyapp.root.ids.sc11.ids.ml.clear_widgets()
+            state.kivyapp.root.ids.sc11.loadAddresslist(None, 'All', '')
+            self.addbook_popup.dismiss()
+            toast('Saved')
+
+    def send_message_to(self):
+        """Method used to fill to_address of composer autofield"""
+        state.kivyapp.set_navbar_for_composer()
+        window_obj = state.kivyapp.root.ids
+        window_obj.sc3.children[1].ids.txt_input.text = self.address
+        window_obj.sc3.children[1].ids.ti.text = ''
+        window_obj.sc3.children[1].ids.btn.text = 'Select'
+        window_obj.sc3.children[1].ids.subject.text = ''
+        window_obj.sc3.children[1].ids.body.text = ''
+        window_obj.scr_mngr.current = 'create'
+        self.addbook_popup.dismiss()

src/bitmessagekivy/baseclass/allmail.py

@@ -0,0 +1,152 @@
+# pylint: disable=import-error, no-name-in-module
+
+"""
+Kivy All mail screen
+"""
+
+from functools import partial
+
+from kivy.clock import Clock
+from kivy.properties import (
+    ListProperty,
+    StringProperty
+)
+from kivy.uix.screenmanager import Screen
+
+from baseclass.common import (
+    showLimitedCnt, toast, ThemeClsColor,
+    avatarImageFirstLetter, CutsomSwipeToDeleteItem,
+    ShowTimeHistoy
+)
+
+from kivymd.uix.label import MDLabel
+
+from pybitmessage import state
+from pybitmessage import kivy_state
+
+
+class Allmails(Screen):
+    """Allmails Screen for kivy Ui"""
+
+    data = ListProperty()
+    has_refreshed = True
+    all_mails = ListProperty()
+    account = StringProperty()
+
+    def __init__(self, *args, **kwargs):
+        """Method Parsing the address"""
+        super(Allmails, self).__init__(*args, **kwargs)
+        if kivy_state.association == '':
+            if state.kivyapp.variable_1:
+                kivy_state.association = state.kivyapp.variable_1[0]
+        Clock.schedule_once(self.init_ui, 0)
+
+    def init_ui(self, dt=0):
+        """Clock Schdule for method all mails"""
+        self.loadMessagelist()
+        print(dt)
+
+    def loadMessagelist(self):
+        """Load Inbox, Sent anf Draft list of messages"""
+        self.account = kivy_state.association
+        self.ids.tag_label.text = ''
+        if self.all_mails:
+            pass
+        else:
+            self.set_AllmailCnt('0')
+            content = MDLabel(
+                font_style='Caption',
+                theme_text_color='Primary',
+                text="yet no message for this account!!!!!!!!!!!!!",
+                halign='center',
+                size_hint_y=None,
+                valign='top')
+            self.ids.ml.add_widget(content)
+
+    def set_AllmailCnt(self, Count):  # pylint: disable=no-self-use
+        """This method is used to set allmails message count"""
+        allmailCnt_obj = state.kivyapp.root.ids.content_drawer.ids.allmail_cnt
+        allmailCnt_obj.ids.badge_txt.text = showLimitedCnt(int(Count))
+
+    def set_mdlist(self):
+        """This method is used to create mdList for allmaills"""
+        data_exist = len(self.ids.ml.children)
+        for item in self.all_mails:
+            body = item[3].decode() if isinstance(item[3], bytes) else item[3]
+            subject = item[2].decode() if isinstance(item[2], bytes) else item[2]
+            message_row = CutsomSwipeToDeleteItem(
+                text=item[1],
+            )
+
+            listItem = message_row.ids.content
+            secondary_text = (subject[:50] + '........' if len(
+                subject) >= 50 else (
+                    subject + ',' + body)[0:50] + '........').replace('\t', '').replace('  ', '')
+            listItem.secondary_text = secondary_text
+            listItem.theme_text_color = "Custom"
+            listItem.text_color = ThemeClsColor
+            # pylint: disable=consider-using-f-string
+            img_latter = kivy_state.imageDir + '/text_images/{}.png'.format(
+                avatarImageFirstLetter(body.strip()))
+            message_row.ids.avater_img.source = img_latter
+            listItem.bind(on_release=partial(
+                self.mail_detail, item[5], item[4], message_row))
+            message_row.ids.time_tag.text = str(ShowTimeHistoy(item[7]))
+            message_row.ids.chip_tag.text = item[4]
+            message_row.ids.delete_msg.bind(on_press=partial(
+                self.swipe_delete, item[5], item[4]))
+            self.ids.ml.add_widget(message_row)
+        updated_data = len(self.ids.ml.children)
+        # pylint: disable=simplifiable-if-expression
+        self.has_refreshed = True if data_exist != updated_data else False
+
+    def check_scroll_y(self):
+        """Scroll fixed length"""
+        if self.ids.scroll_y.scroll_y <= -0.00 and self.has_refreshed:
+            self.ids.scroll_y.scroll_y = .06
+
+    def mail_detail(self, unique_id, folder, instance):
+        """Load sent and inbox mail details"""
+        if instance.state == 'closed':
+            instance.ids.delete_msg.disabled = True
+            if instance.open_progress == 0.0:
+                kivy_state.detailPageType = folder
+                kivy_state.is_allmail = True
+                kivy_state.mail_id = unique_id
+                if self.manager:
+                    src_mng_obj = self.manager
+                else:
+                    src_mng_obj = self.parent.parent
+                src_mng_obj.screens[11].clear_widgets()
+                src_mng_obj.current = 'mailDetail'
+        else:
+            instance.ids.delete_msg.disabled = False
+
+    def swipe_delete(self, folder, instance):
+        """Delete inbox mail from all mail listing"""
+        self.ids.ml.remove_widget(instance.parent.parent)
+        try:
+            msg_count_objs = self.parent.parent.ids.content_drawer.ids
+            nav_lay_obj = self.parent.parent.ids
+        except Exception:
+            msg_count_objs = self.parent.parent.parent.ids.content_drawer.ids
+            nav_lay_obj = self.parent.parent.parent.ids
+        if folder == 'inbox':
+            msg_count_objs.inbox_cnt.ids.badge_txt.text = showLimitedCnt(int(kivy_state.inbox_count) - 1)
+            kivy_state.inbox_count = str(int(kivy_state.inbox_count) - 1)
+            nav_lay_obj.sc1.ids.ml.clear_widgets()
+            nav_lay_obj.sc1.loadMessagelist(kivy_state.association)
+        else:
+            msg_count_objs.send_cnt.ids.badge_txt.text = showLimitedCnt(int(kivy_state.sent_count) - 1)
+            kivy_state.sent_count = str(int(kivy_state.sent_count) - 1)
+            nav_lay_obj.sc4.ids.ml.clear_widgets()
+            nav_lay_obj.sc4.loadSent(kivy_state.association)
+        if folder != 'inbox':
+            msg_count_objs.allmail_cnt.ids.badge_txt.text = showLimitedCnt(int(kivy_state.all_count) - 1)
+            kivy_state.all_count = str(int(kivy_state.all_count) - 1)
+        msg_count_objs.trash_cnt.ids.badge_txt.text = showLimitedCnt(int(kivy_state.trash_count) + 1)
+        kivy_state.trash_count = str(int(kivy_state.trash_count) + 1)
+        if int(kivy_state.all_count) <= 0:
+            self.ids.tag_label.text = ''
+        nav_lay_obj.sc17.remove_widget(instance.parent.parent)
+        toast('Deleted')

src/bitmessagekivy/baseclass/common.py

@@ -0,0 +1,125 @@
+# pylint: disable=import-error, no-name-in-module
+# pylint: disable=import-outside-toplevel, abstract-method
+
+"""
+Kivy Common UI Widget
+"""
+
+from datetime import datetime
+
+from kivy.core.window import Window
+from kivy.metrics import dp
+from kivy.properties import (
+    NumericProperty,
+    StringProperty
+)
+from kivy.uix.image import Image
+
+from kivymd.uix.list import (
+    ILeftBody,
+    IRightBodyTouch,
+)
+from kivymd.uix.label import MDLabel
+from kivymd.toast import kivytoast
+from kivymd.uix.card import MDCardSwipe
+from kivymd.uix.chip import MDChip
+
+# from pybitmessage.get_platform import platform
+platform = "linux"
+
+
+ThemeClsColor = [0.12, 0.58, 0.95, 1]
+
+
+data_screens = {
+    "MailDetail": {
+        "kv_string": "maildetail",
+        "Factory": "MailDetail()",
+        "name_screen": "mailDetail",
+        "object": 0,
+        "Import": "from  baseclass.maildetail import MailDetail",
+    },
+}
+
+
+def chipTag(text):
+    """This method is used for showing chip tag"""
+    obj = MDChip()
+    # obj.size_hint = (None, None)
+    obj.size_hint = (0.16 if platform == "android" else 0.08, None)
+    obj.text = text
+    obj.icon = ""
+    obj.pos_hint = {
+        "center_x": 0.91 if platform == "android" else 0.94,
+        "center_y": 0.3
+    }
+    obj.height = dp(18)
+    obj.text_color = (1, 1, 1, 1)
+    obj.radius = [8]
+    return obj
+
+
+def toast(text):
+    """Method will display the toast message"""
+    kivytoast.toast(text)
+
+
+def showLimitedCnt(total_msg):
+    """This method set the total count limit in badge_text"""
+    return "99+" if total_msg > 99 else str(total_msg)
+
+
+def avatarImageFirstLetter(letter_string):
+    """This function is used to the first letter for the avatar image"""
+    try:
+        if letter_string[0].upper() >= 'A' and letter_string[0].upper() <= 'Z':
+            img_latter = letter_string[0].upper()
+        elif int(letter_string[0]) >= 0 and int(letter_string[0]) <= 9:
+            img_latter = letter_string[0]
+        else:
+            img_latter = '!'
+    except ValueError:
+        img_latter = '!'
+    return img_latter if img_latter else '!'
+
+
+def ShowTimeHistoy(act_time):
+    """This method is used to return the message sent or receive time"""
+    action_time = datetime.fromtimestamp(int(act_time))
+    crnt_date = datetime.now()
+    duration = crnt_date - action_time
+    display_data = (
+        action_time.strftime("%d/%m/%Y")
+        if duration.days >= 365
+        else action_time.strftime("%I:%M %p").lstrip("0")
+        if duration.days == 0 and crnt_date.strftime("%d/%m/%Y") == action_time.strftime("%d/%m/%Y")
+        else action_time.strftime("%d %b")
+    )
+    return display_data
+
+
+# pylint: disable=too-few-public-methods
+class AvatarSampleWidget(ILeftBody, Image):
+    """AvatarSampleWidget class for kivy Ui"""
+
+
+# pylint: disable=too-many-ancestors
+class TimeTagRightSampleWidget(IRightBodyTouch, MDLabel):
+    """TimeTagRightSampleWidget class for Ui"""
+
+
+class SwipeToDeleteItem(MDCardSwipe):
+    """Swipe delete class for App UI"""
+    text = StringProperty()
+    cla = Window.size[0] / 2
+    # cla = 800
+    swipe_distance = NumericProperty(cla)
+    opening_time = NumericProperty(0.5)
+
+
+class CutsomSwipeToDeleteItem(MDCardSwipe):
+    """Custom swipe delete class for App UI"""
+    text = StringProperty()
+    cla = Window.size[0] / 2
+    swipe_distance = NumericProperty(cla)
+    opening_time = NumericProperty(0.5)

src/bitmessagekivy/baseclass/draft.py

@@ -0,0 +1,156 @@
+# pylint: disable=import-error, no-name-in-module, import-outside-toplevel,simplifiable-if-expression
+
+"""
+Kivy Draft screen
+"""
+
+from functools import partial
+
+from kivy.clock import Clock
+from kivy.properties import (
+    ListProperty,
+    StringProperty
+)
+from kivy.uix.screenmanager import Screen
+
+from baseclass.common import (
+    showLimitedCnt, toast, ThemeClsColor,
+    SwipeToDeleteItem, ShowTimeHistoy
+)
+
+from kivymd.uix.label import MDLabel
+
+from pybitmessage import state
+from pybitmessage import kivy_state
+
+
+class Draft(Screen):
+    """Draft screen class for kivy Ui"""
+
+    data = ListProperty()
+    account = StringProperty()
+    queryreturn = ListProperty()
+    has_refreshed = True
+
+    def __init__(self, *args, **kwargs):
+        """Method used for storing draft messages"""
+        super(Draft, self).__init__(*args, **kwargs)
+        if kivy_state.association == '':
+            if state.kivyapp.variable_1:
+                kivy_state.association = state.kivyapp.variable_1[0]
+        Clock.schedule_once(self.init_ui, 0)
+
+    def init_ui(self, dt=0):
+        """Clock Schdule for method draft accounts"""
+        self.sentaccounts()
+        print(dt)
+
+    def sentaccounts(self):
+        """Load draft accounts"""
+        # self.account = state.association
+        self.loadDraft()
+
+    def loadDraft(self):
+        """Load draft list for Draft messages"""
+        self.account = kivy_state.association
+        self.ids.tag_label.text = ''
+        if self.queryreturn:
+            self.ids.tag_label.text = 'Draft'
+            self.set_draftCnt(kivy_state.draft_count)
+            self.set_mdList()
+            self.ids.scroll_y.bind(scroll_y=self.check_scroll_y)
+        else:
+            self.set_draftCnt('0')
+            content = MDLabel(
+                font_style='Caption',
+                theme_text_color='Primary',
+                text="yet no message for this account!!!!!!!!!!!!!",
+                halign='center',
+                size_hint_y=None,
+                valign='top')
+            self.ids.ml.add_widget(content)
+
+    def set_draftCnt(self, Count):  # pylint: disable=no-self-use
+        """This method set the count of draft mails"""
+        draftCnt_obj = state.kivyapp.root.ids.content_drawer.ids.draft_cnt
+        draftCnt_obj.ids.badge_txt.text = showLimitedCnt(int(Count))
+
+    def set_mdList(self):
+        """This method is used to create mdlist"""
+        data = []
+        total_draft_msg = len(self.ids.ml.children)
+        for mail in self.queryreturn:
+            third_text = mail[3].replace('\n', ' ')
+            data.append({
+                'text': mail[1].strip(),
+                'secondary_text': mail[2][:10] + '...........' if len(
+                    mail[2]) > 10 else mail[2] + '\n' + " " + (
+                        third_text[:25] + '...!') if len(
+                            third_text) > 25 else third_text,
+                'ackdata': mail[5], 'senttime': mail[6]})
+        for item in data:
+            message_row = SwipeToDeleteItem(
+                text='Draft',
+            )
+            listItem = message_row.ids.content
+            listItem.secondary_text = item["text"]
+            listItem.theme_text_color = "Custom"
+            listItem.text_color = ThemeClsColor
+            message_row.ids.avater_img.source = kivy_state.imageDir + '/avatar.png'
+            listItem.bind(on_release=partial(
+                self.draft_detail, item['ackdata'], message_row))
+            message_row.ids.time_tag.text = str(ShowTimeHistoy(item['senttime']))
+            message_row.ids.delete_msg.bind(on_press=partial(self.delete_draft, item['ackdata']))
+            self.ids.ml.add_widget(message_row)
+        updated_msg = len(self.ids.ml.children)
+        self.has_refreshed = True if total_draft_msg != updated_msg else False
+
+    def check_scroll_y(self):
+        """Load data on scroll"""
+        if self.ids.scroll_y.scroll_y <= -0.0 and self.has_refreshed:
+            self.ids.scroll_y.scroll_y = 0.06
+
+    def draft_detail(self, ackdata, instance):
+        """Show draft Details"""
+        if instance.state == 'closed':
+            instance.ids.delete_msg.disabled = True
+            if instance.open_progress == 0.0:
+                kivy_state.detailPageType = 'draft'
+                kivy_state.mail_id = ackdata
+                if self.manager:
+                    src_mng_obj = self.manager
+                else:
+                    src_mng_obj = self.parent.parent
+                src_mng_obj.screens[11].clear_widgets()
+                # src_mng_obj.screens[11].add_widget(MailDetail())
+                src_mng_obj.current = 'mailDetail'
+        else:
+            instance.ids.delete_msg.disabled = False
+
+    def delete_draft(self, instance):
+        """Delete draft message permanently"""
+        if int(kivy_state.draft_count) > 0:
+            kivy_state.draft_count = str(int(kivy_state.draft_count) - 1)
+            self.set_draftCnt(kivy_state.draft_count)
+            if int(kivy_state.draft_count) <= 0:
+                # self.ids.identi_tag.children[0].text = ''
+                self.ids.tag_label.text = ''
+        self.ids.ml.remove_widget(instance.parent.parent)
+        toast('Deleted')
+
+    @staticmethod
+    def draft_msg(src_object):
+        """Save draft mails"""
+        composer_object = state.kivyapp.root.ids.sc3.children[1].ids
+        fromAddress = str(composer_object.ti.text)
+        toAddress = str(composer_object.txt_input.text)
+        sendMessageToPeople = True
+        if sendMessageToPeople:
+            from pybitmessage.addresses import addBMIfNotPresent
+            toAddress = addBMIfNotPresent(toAddress)
+            kivy_state.msg_counter_objs = src_object.children[2].children[0].ids
+            kivy_state.draft_count = str(int(kivy_state.draft_count) + 1) \
+                if kivy_state.association == fromAddress else kivy_state.draft_count
+            src_object.ids.sc16.clear_widgets()
+            src_object.ids.sc16.add_widget(Draft())
+            toast('Save draft')

src/bitmessagekivy/baseclass/inbox.py

@@ -0,0 +1,81 @@
+# pylint: disable=import-error, no-name-in-module
+# pylint: disable=import-outside-toplevel, simplifiable-if-expression
+
+"""
+Kivy Inbox screen
+"""
+
+from kivy.clock import Clock
+from kivy.properties import (
+    ListProperty,
+    StringProperty
+)
+from kivy.uix.screenmanager import Screen
+
+from baseclass.common import showLimitedCnt
+
+from kivymd.uix.label import MDLabel
+
+from pybitmessage import state
+from pybitmessage import kivy_state
+
+
+class Inbox(Screen):
+    """Inbox Screen class for kivy Ui"""
+
+    queryreturn = ListProperty()
+    has_refreshed = True
+    account = StringProperty()
+
+    def __init__(self, *args, **kwargs):
+        """Method Parsing the address"""
+        super(Inbox, self).__init__(*args, **kwargs)
+        Clock.schedule_once(self.init_ui, 0)
+
+    @staticmethod
+    def set_defaultAddress():
+        """This method set's default address"""
+        if kivy_state.association == "":
+            if state.kivyapp.variable_1:
+                kivy_state.association = state.kivyapp.variable_1[0]
+
+    def init_ui(self):
+        """Clock schdule for method inbox accounts"""
+        self.loadMessagelist()
+
+    def loadMessagelist(self):
+        """Load Inbox list for Inbox messages"""
+        self.set_defaultAddress()
+        self.account = kivy_state.association
+        if kivy_state.searcing_text:
+            self.ids.scroll_y.scroll_y = 1.0
+        self.ids.tag_label.text = ""
+        if self.queryreturn:
+            pass
+        else:
+            self.set_inboxCount("0")
+            content = MDLabel(
+                font_style="Caption",
+                theme_text_color="Primary",
+                text="No message found!"
+                if kivy_state.searcing_text
+                else "yet no message for this account!!!!!!!!!!!!!",
+                halign="center",
+                size_hint_y=None,
+                valign="top"
+            )
+            self.ids.ml.add_widget(content)
+
+    def set_inboxCount(self, msgCnt):  # pylint: disable=no-self-use
+        """This method is used to sent inbox message count"""
+        src_mng_obj = state.kivyapp.root.ids.content_drawer.ids
+        src_mng_obj.inbox_cnt.ids.badge_txt.text = showLimitedCnt(int(msgCnt))
+        state.kivyapp.get_sent_count()
+        kivy_state.all_count = str(
+            int(kivy_state.sent_count) + int(kivy_state.inbox_count))
+        src_mng_obj.allmail_cnt.ids.badge_txt.text = showLimitedCnt(int(kivy_state.all_count))
+
+    def check_scroll_y(self):
+        """Loads data on scroll"""
+        if self.ids.scroll_y.scroll_y <= -0.0 and self.has_refreshed:
+            self.ids.scroll_y.scroll_y = 0.06

src/bitmessagekivy/baseclass/login.py

@@ -0,0 +1,119 @@
+# pylint: disable=import-error, no-name-in-module, too-few-public-methods
+
+
+"""
+Kivy Login screen
+"""
+
+from kivy.clock import Clock
+from kivy.properties import StringProperty, BooleanProperty
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.screenmanager import Screen
+
+from baseclass.common import toast
+
+from kivymd.uix.behaviors.elevation import RectangularElevationBehavior
+
+from pybitmessage.bmconfigparser import config
+from pybitmessage import queues
+from pybitmessage import state
+
+
+class Login(Screen):
+    """Login Screeen class for kivy Ui"""
+    # pylint: disable=too-few-public-methods
+    log_text1 = (
+        'You may generate addresses by using either random numbers'
+        ' or by using a passphrase If you use a passphrase, the address'
+        ' is called a deterministic; address The Random Number option is'
+        ' selected by default but deterministic addresses have several pros'
+        ' and cons:')
+    log_text2 = ('If talk about pros You can recreate your addresses on any computer'
+                 ' from memory, You need-not worry about backing up your keys.dat file'
+                 ' as long as you can remember your passphrase and aside talk about cons'
+                 ' You must remember (or write down) your  You must remember the address'
+                 ' version number and the stream number along with your passphrase If you'
+                 ' choose a weak passphrase and someone on the Internet can brute-force it,'
+                 ' they can read your messages and send messages as you')
+
+
+class Random(Screen):
+    """Random Screen class for Ui"""
+
+    is_active = BooleanProperty(False)
+    checked = StringProperty("")
+
+    def generateaddress(self):
+        """Method for Address Generator"""
+        # entered_label = str(self.ids.lab.text).strip()
+        entered_label = str(self.ids.add_random_bx.children[0].ids.lab.text).strip()
+        if not entered_label:
+            self.ids.add_random_bx.children[0].ids.lab.focus = True
+        streamNumberForAddress = 1
+        eighteenByteRipe = False
+        nonceTrialsPerByte = 1000
+        payloadLengthExtraBytes = 1000
+        lables = [config.get(obj, 'label')
+                  for obj in config.addresses()]
+        if entered_label and entered_label not in lables:
+            toast('Address Creating...')
+            queues.addressGeneratorQueue.put((
+                'createRandomAddress', 4, streamNumberForAddress, entered_label, 1,
+                "", eighteenByteRipe, nonceTrialsPerByte,
+                payloadLengthExtraBytes))
+            self.parent.parent.ids.toolbar.opacity = 1
+            self.parent.parent.ids.toolbar.disabled = False
+            state.kivyapp.loadMyAddressScreen(True)
+            self.manager.current = 'myaddress'
+            Clock.schedule_once(self.address_created_callback, 6)
+
+    def address_created_callback(self, dt=0):  # pylint: disable=unused-argument
+        """New address created"""
+        state.kivyapp.loadMyAddressScreen(False)
+        state.kivyapp.root.ids.sc10.ids.ml.clear_widgets()
+        state.kivyapp.root.ids.sc10.is_add_created = True
+        state.kivyapp.root.ids.sc10.init_ui()
+        self.reset_address_spinner()
+        toast('New address created')
+
+    def reset_address_spinner(self):
+        """reseting spinner address and UI"""
+        addresses = [addr for addr in config.addresses()
+                     if config.get(str(addr), 'enabled') == 'true']
+        self.manager.parent.ids.content_drawer.ids.btn.values = []
+        self.manager.parent.ids.sc3.children[1].ids.btn.values = []
+        self.manager.parent.ids.content_drawer.ids.btn.values = addresses
+        self.manager.parent.ids.sc3.children[1].ids.btn.values = addresses
+
+    @staticmethod
+    def add_validation(instance):
+        """Checking validation at address creation time"""
+        entered_label = str(instance.text.strip())
+        lables = [config.get(obj, 'label')
+                  for obj in config.addresses()]
+        # pylint: disable=consider-using-f-string
+        if entered_label in lables:
+            instance.error = True
+            instance.helper_text = 'it is already exist you'\
+                ' can try this Ex. ( {0}_1, {0}_2 )'.format(
+                    entered_label)
+        elif entered_label:
+            instance.error = False
+        else:
+            instance.error = False
+            instance.helper_text = 'This field is required'
+
+    def reset_address_label(self):
+        """Resetting address labels"""
+        if not self.ids.add_random_bx.children:
+            self.ids.add_random_bx.add_widget(RandomBoxlayout())
+
+
+class InfoLayout(BoxLayout, RectangularElevationBehavior):
+    """InfoLayout class for kivy Ui"""
+    # pylint: disable=too-few-public-methods
+
+
+class RandomBoxlayout(BoxLayout):
+    """RandomBoxlayout class for BoxLayout behaviour"""
+    # pylint: disable=too-few-public-methods

src/bitmessagekivy/baseclass/maildetail.py

@@ -0,0 +1,238 @@
+# pylint: disable=import-error, no-name-in-module, unused-argument, too-many-ancestors, attribute-defined-outside-init
+# pylint: disable=import-outside-toplevel, too-many-function-args
+
+
+"""
+Kivy Mail Detail screen
+"""
+
+from datetime import datetime
+
+from kivy.core.clipboard import Clipboard
+from kivy.clock import Clock
+from kivy.properties import (
+    StringProperty,
+    NumericProperty
+)
+from kivy.factory import Factory
+from kivy.uix.screenmanager import Screen
+
+from kivymd.uix.button import MDFlatButton, MDIconButton
+from kivymd.uix.dialog import MDDialog
+from kivymd.uix.list import (
+    OneLineListItem,
+    IRightBodyTouch
+)
+
+from pybitmessage import state
+from pybitmessage import kivy_state
+
+from .common import (
+    toast, avatarImageFirstLetter, ShowTimeHistoy
+)
+from .popup import SenderDetailPopup
+
+
+# from pybitmessage.get_platform import platform
+platform = "linux"
+
+
+class OneLineListTitle(OneLineListItem):
+    """OneLineListTitle class for kivy Ui"""
+    __events__ = ('on_long_press', )
+    long_press_time = NumericProperty(1)
+
+    def on_state(self, instance, value):
+        """On state"""
+        if value == 'down':
+            lpt = self.long_press_time
+            self._clockev = Clock.schedule_once(self._do_long_press, lpt)
+        else:
+            self._clockev.cancel()
+
+    def _do_long_press(self, dt):
+        """Do long press"""
+        self.dispatch('on_long_press')
+
+    def on_long_press(self, *largs):
+        """On long press"""
+        self.copymessageTitle(self.text)
+
+    def copymessageTitle(self, title_text):
+        """this method is for displaying dialog box"""
+        self.title_text = title_text
+        width = .8 if platform == 'android' else .55
+        self.dialog_box = MDDialog(
+            text=title_text,
+            size_hint=(width, .25),
+            buttons=[
+                MDFlatButton(
+                    text="Copy", on_release=self.callback_for_copy_title
+                ),
+                MDFlatButton(
+                    text="Cancel", on_release=self.callback_for_copy_title,
+                ),
+            ],)
+        self.dialog_box.open()
+
+    def callback_for_copy_title(self, instance):
+        """Callback of alert box"""
+        if instance.text == 'Copy':
+            Clipboard.copy(self.title_text)
+        self.dialog_box.dismiss()
+        toast(instance.text)
+
+
+class IconRightSampleWidget(IRightBodyTouch, MDIconButton):
+    """IconRightSampleWidget class for kivy Ui"""
+
+
+class MailDetail(Screen):  # pylint: disable=too-many-instance-attributes
+    """MailDetail Screen class for kivy Ui"""
+
+    to_addr = StringProperty()
+    from_addr = StringProperty()
+    subject = StringProperty()
+    message = StringProperty()
+    status = StringProperty()
+    page_type = StringProperty()
+    time_tag = StringProperty()
+    avatarImg = StringProperty()
+
+    def __init__(self, *args, **kwargs):
+        """Mail Details method"""
+        super(MailDetail, self).__init__(*args, **kwargs)
+        Clock.schedule_once(self.init_ui, 0)
+
+    def init_ui(self, dt=0):
+        """Clock Schdule for method MailDetail mails"""
+        # pylint: disable=consider-using-in, no-member, unused-variable
+        self.page_type = state.detailPageType if kivy_state.detailPageType else ''
+        try:
+            if kivy_state.detailPageType == 'sent' or kivy_state.detailPageType == 'draft':
+                data = []
+                state.status = self
+                state.ackdata = data[0][5]
+                self.assign_mail_details(data)
+                state.kivyapp.set_mail_detail_header()
+            elif kivy_state.detailPageType == 'inbox':
+                data = []
+                self.assign_mail_details(data)
+                state.kivyapp.set_mail_detail_header()
+        except Exception as e:
+            print('Something wents wrong!!')
+
+    def assign_mail_details(self, data):
+        """Assigning mail details"""
+        subject = data[0][2].decode() if isinstance(data[0][2], bytes) else data[0][2]
+        body = data[0][3].decode() if isinstance(data[0][2], bytes) else data[0][3]
+        self.to_addr = data[0][0] if len(data[0][0]) > 4 else ' '
+        self.from_addr = data[0][1]
+
+        self.subject = subject.capitalize(
+        ) if subject.capitalize() else '(no subject)'
+        self.message = body
+        if len(data[0]) == 7:
+            self.status = data[0][4]
+        self.time_tag = ShowTimeHistoy(data[0][4]) \
+            if kivy_state.detailPageType == 'inbox' else ShowTimeHistoy(data[0][6])
+        self.avatarImg = kivy_state.imageDir + '/avatar.png' if kivy_state.detailPageType == 'draft' else (
+            kivy_state.imageDir + f'/text_images/{avatarImageFirstLetter(self.subject.strip(9))}.png')  # noqa:E999
+        self.timeinseconds = data[0][4] if kivy_state.detailPageType == 'inbox' else data[0][6]
+
+    def delete_mail(self):
+        """Method for mail delete"""
+        msg_count_objs = state.kivyapp.root.ids.content_drawer.ids
+        kivy_state.searcing_text = ''
+        self.children[0].children[0].active = True
+        if kivy_state.detailPageType == 'sent':
+            state.kivyapp.root.ids.sc4.ids.sent_search.ids.search_field.text = ''
+            msg_count_objs.send_cnt.ids.badge_txt.text = str(int(kivy_state.sent_count) - 1)
+            kivy_state.sent_count = str(int(kivy_state.sent_count) - 1)
+            self.parent.screens[2].ids.ml.clear_widgets()
+            self.parent.screens[2].loadSent(kivy_state.association)
+        elif kivy_state.detailPageType == 'inbox':
+            state.kivyapp.root.ids.sc1.ids.inbox_search.ids.search_field.text = ''
+            msg_count_objs.inbox_cnt.ids.badge_txt.text = str(
+                int(kivy_state.inbox_count) - 1)
+            kivy_state.inbox_count = str(int(kivy_state.inbox_count) - 1)
+            self.parent.screens[0].ids.ml.clear_widgets()
+            self.parent.screens[0].loadMessagelist(kivy_state.association)
+
+        elif kivy_state.detailPageType == 'draft':
+            msg_count_objs.draft_cnt.ids.badge_txt.text = str(
+                int(kivy_state.draft_count) - 1)
+            kivy_state.draft_count = str(int(kivy_state.draft_count) - 1)
+            self.parent.screens[13].clear_widgets()
+            self.parent.screens[13].add_widget(Factory.Draft())
+
+        if kivy_state.detailPageType != 'draft':
+            msg_count_objs.trash_cnt.ids.badge_txt.text = str(
+                int(kivy_state.trash_count) + 1)
+            msg_count_objs.allmail_cnt.ids.badge_txt.text = str(
+                int(kivy_state.all_count) - 1)
+            kivy_state.trash_count = str(int(kivy_state.trash_count) + 1)
+            kivy_state.all_count = str(int(kivy_state.all_count) - 1) if int(kivy_state.all_count) else '0'
+            self.parent.screens[3].clear_widgets()
+            self.parent.screens[3].add_widget(Factory.Trash())
+            self.parent.screens[14].clear_widgets()
+            self.parent.screens[14].add_widget(Factory.Allmails())
+        Clock.schedule_once(self.callback_for_delete, 4)
+
+    def callback_for_delete(self, dt=0):
+        """Delete method from allmails"""
+        if kivy_state.detailPageType:
+            self.children[0].children[0].active = False
+            state.kivyapp.set_common_header()
+            self.parent.current = 'allmails' \
+                if kivy_state.is_allmail else kivy_state.detailPageType
+            kivy_state.detailPageType = ''
+            toast('Deleted')
+
+    def inbox_reply(self):
+        """Reply inbox messages"""
+        kivy_state.in_composer = True
+        data = []
+        composer_obj = self.parent.screens[1].children[1].ids
+        composer_obj.ti.text = data[0][0]
+        composer_obj.btn.text = data[0][0]
+        composer_obj.txt_input.text = data[0][1]
+        split_subject = data[0][2].split('Re:', 1)
+        composer_obj.subject.text = 'Re: ' + (split_subject[1] if len(split_subject) > 1 else split_subject[0])
+        time_obj = datetime.fromtimestamp(int(data[0][4]))
+        time_tag = time_obj.strftime("%d %b %Y, %I:%M %p")
+        # sender_name = config.get(data[0][1], 'label')
+        sender_name = data[0][1]
+        composer_obj.body.text = (
+            '\n\n --------------On ' + time_tag + ', ' + sender_name + ' wrote:--------------\n' + data[0][3])
+        composer_obj.body.focus = True
+        composer_obj.body.cursor = (0, 0)
+        state.kivyapp.root.ids.sc3.children[1].ids.rv.data = ''
+        self.parent.current = 'create'
+        state.kivyapp.set_navbar_for_composer()
+
+    def write_msg(self, navApp):
+        """Write on draft mail"""
+        kivy_state.send_draft_mail = kivy_state.mail_id
+        data = []
+        composer_ids = (
+            self.parent.parent.ids.sc3.children[1].ids)
+        composer_ids.ti.text = data[0][1]
+        composer_ids.btn.text = data[0][1]
+        composer_ids.txt_input.text = data[0][0]
+        composer_ids.subject.text = data[0][2] if data[0][2] != '(no subject)' else ''
+        composer_ids.body.text = data[0][3]
+        self.parent.current = 'create'
+        navApp.set_navbar_for_composer()
+
+    def detailedPopup(self):
+        """Detailed popup"""
+        obj = SenderDetailPopup()
+        obj.open()
+        arg = (self.to_addr, self.from_addr, self.timeinseconds)
+        obj.assignDetail(*arg)
+
+    @staticmethod
+    def callback_for_menu_items(text_item, *arg):
+        """Callback of alert box"""
+        toast(text_item)

src/bitmessagekivy/baseclass/msg_composer.py

@@ -0,0 +1,260 @@
+# pylint: disable=import-error, no-name-in-module, unused-variable, too-many-ancestors
+# pylint: disable=too-few-public-methods, unused-argument
+"""
+Kivy Mail Composer screen
+"""
+
+from kivy.clock import Clock
+from kivy.core.window import Window
+from kivy.factory import Factory
+from kivy.properties import (
+    BooleanProperty,
+    ListProperty,
+    NumericProperty,
+    ObjectProperty,
+)
+from kivy.uix.behaviors import FocusBehavior
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.label import Label
+from kivy.uix.recycleview import RecycleView
+from kivy.uix.recycleboxlayout import RecycleBoxLayout
+from kivy.uix.recycleview.layout import LayoutSelectionBehavior
+from kivy.uix.recycleview.views import RecycleDataViewBehavior
+from kivy.uix.screenmanager import Screen
+
+from baseclass.common import (
+    toast, showLimitedCnt
+)
+
+from kivymd.uix.textfield import MDTextField
+from kivymd.uix.button import MDFlatButton
+from kivymd.uix.dialog import MDDialog
+
+from pybitmessage import state
+from pybitmessage import kivy_state
+from pybitmessage import queues
+
+from pybitmessage.addresses import decodeAddress, addBMIfNotPresent
+from pybitmessage.get_platform import platform
+from pybitmessage.bmconfigparser import config
+
+
+class Create(Screen):
+    """Creates Screen class for kivy Ui"""
+
+    def __init__(self, **kwargs):
+        """Getting Labels and address from addressbook"""
+        super(Create, self).__init__(**kwargs)
+        Window.softinput_mode = "below_target"
+        widget_1 = DropDownWidget()
+        widget_1.ids.txt_input.word_list = []
+        widget_1.ids.txt_input.starting_no = 2
+        self.add_widget(widget_1)
+        self.children[0].ids.id_scroll.bind(scroll_y=self.check_scroll_y)
+
+    def check_scroll_y(self, instance, somethingelse):
+        """show data on scroll down"""
+        if self.children[1].ids.btn.is_open:
+            self.children[1].ids.btn.is_open = False
+
+
+class RV(RecycleView):
+    """Recycling View class for kivy Ui"""
+
+
+class SelectableRecycleBoxLayout(
+    FocusBehavior, LayoutSelectionBehavior, RecycleBoxLayout
+):
+    """Adds selection and focus behaviour to the view"""
+
+
+class DropDownWidget(BoxLayout):
+    """DropDownWidget class for kivy Ui"""
+
+    # pylint: disable=too-many-statements
+
+    txt_input = ObjectProperty()
+    rv = ObjectProperty()
+
+    def send(self, navApp):
+        """Send message from one address to another"""
+        fromAddress = self.ids.ti.text.strip()
+        toAddress = self.ids.txt_input.text.strip()
+        subject = self.ids.subject.text.strip()
+        message = self.ids.body.text.strip()
+        print("message: ", self.ids.body.text)
+        if toAddress != "" and subject and message:
+            status, addressVersionNumber, streamNumber, ripe = decodeAddress(
+                toAddress
+            )
+            if status == "success":
+                navApp.root.ids.sc3.children[0].active = True
+                if kivy_state.detailPageType == "draft" and kivy_state.send_draft_mail:
+                    self.parent.parent.screens[13].clear_widgets()
+                    self.parent.parent.screens[13].add_widget(Factory.Draft())
+                else:
+                    if (addressVersionNumber > 4) or (
+                            addressVersionNumber <= 1):
+                        print(
+                            "addressVersionNumber > 4"
+                            " or addressVersionNumber <= 1")
+                    if streamNumber > 1 or streamNumber == 0:
+                        print("streamNumber > 1 or streamNumber == 0")
+                    stealthLevel = config.safeGetInt(
+                        'bitmessagesettings', 'ackstealthlevel')
+
+                kivy_state.check_sent_acc = fromAddress
+                if kivy_state.detailPageType == 'draft' \
+                        and kivy_state.send_draft_mail:
+                    kivy_state.draft_count = str(int(kivy_state.draft_count) - 1)
+                    kivy_state.detailPageType = ''
+                    kivy_state.send_draft_mail = None
+                self.parent.parent.parent.ids.sc4.update_sent_messagelist()
+                allmailCnt_obj = state.kivyapp.root.ids.content_drawer.ids.allmail_cnt
+                allmailCnt_obj.ids.badge_txt.text = showLimitedCnt(int(kivy_state.all_count) + 1)
+                kivy_state.all_count = str(int(kivy_state.all_count) + 1)
+                Clock.schedule_once(self.callback_for_msgsend, 3)
+                queues.workerQueue.put(('sendmessage', addBMIfNotPresent(toAddress)))
+                print("sqlExecute successfully #######################")
+                kivy_state.in_composer = True
+            else:
+                msg = 'Enter a valid recipients address'
+        elif not toAddress:
+            msg = 'Please fill the form completely'
+        else:
+            msg = 'Please fill the form completely'
+        self.address_error_message(msg)
+
+    @staticmethod
+    def callback_for_msgsend(dt=0):  # pylint: disable=unused-argument
+        """Callback method for messagesend"""
+        state.kivyapp.root.ids.sc3.children[0].active = False
+        kivy_state.in_sent_method = True
+        state.kivyapp.back_press()
+        toast("sent")
+
+    @staticmethod
+    def address_error_message(msg):
+        """Generates error message"""
+        width = .8 if platform == 'android' else .55
+        dialog_box = MDDialog(
+            text=msg,
+            size_hint=(width, .25),
+            buttons=[
+                MDFlatButton(
+                    text="Ok", on_release=lambda x: callback_for_menu_items("Ok")
+                ),
+            ],)
+        dialog_box.open()
+
+        def callback_for_menu_items(text_item, *arg):
+            """Callback of alert box"""
+            dialog_box.dismiss()
+            toast(text_item)
+
+    def reset_composer(self):
+        """Method will reset composer"""
+        self.ids.ti.text = ""
+        self.ids.btn.text = "Select"
+        self.ids.txt_input.text = ""
+        self.ids.subject.text = ""
+        self.ids.body.text = ""
+        toast("Reset message")
+
+    def auto_fill_fromaddr(self):
+        """Fill the text automatically From Address"""
+        self.ids.ti.text = self.ids.btn.text
+        self.ids.ti.focus = True
+
+    def is_camara_attached(self):
+        """Checks the camera availability in device"""
+        self.parent.parent.parent.ids.sc23.check_camera()
+        is_available = self.parent.parent.parent.ids.sc23.camera_avaialbe
+        return is_available
+
+    @staticmethod
+    def camera_alert():
+        """Show camera availability alert message"""
+        width = .8 if platform == 'android' else .55
+        altet_txt = 'Currently this feature is not avaialbe!'if platform == 'android' else 'Camera is not available!'
+        dialog_box = MDDialog(
+            text=altet_txt,
+            size_hint=(width, .25),
+            buttons=[
+                MDFlatButton(
+                    text="Ok", on_release=lambda x: callback_for_menu_items("Ok")
+                ),
+            ],
+        )
+        dialog_box.open()
+
+        def callback_for_menu_items(text_item, *arg):
+            """Callback of alert box"""
+            dialog_box.dismiss()
+            toast(text_item)
+
+
+class MyTextInput(MDTextField):
+    """MyTextInput class for kivy Ui"""
+
+    txt_input = ObjectProperty()
+    flt_list = ObjectProperty()
+    word_list = ListProperty()
+    starting_no = NumericProperty(3)
+    suggestion_text = ''
+
+    def __init__(self, **kwargs):
+        """Getting Text Input."""
+        super(MyTextInput, self).__init__(**kwargs)
+        self.__lineBreak__ = 0
+
+    def on_text(self, instance, value):  # pylint: disable=unused-argument
+        """Find all the occurrence of the word"""
+        self.parent.parent.parent.parent.parent.ids.rv.data = []
+        matches = [self.word_list[i] for i in range(
+            len(self.word_list)) if self.word_list[
+                i][:self.starting_no] == value[:self.starting_no]]
+        display_data = []
+        for i in matches:
+            display_data.append({'text': i})
+        self.parent.parent.parent.parent.parent.ids.rv.data = display_data
+        if len(matches) <= 10:
+            self.parent.height = (250 + (len(matches) * 20))
+        else:
+            self.parent.height = 400
+
+    def keyboard_on_key_down(self, window, keycode, text, modifiers):
+        """Keyboard on key Down"""
+        if self.suggestion_text and keycode[1] == 'tab':
+            self.insert_text(self.suggestion_text + ' ')
+            return True
+        return super(MyTextInput, self).keyboard_on_key_down(
+            window, keycode, text, modifiers)
+
+
+class SelectableLabel(RecycleDataViewBehavior, Label):
+    """Add selection support to the Label"""
+
+    index = None
+    selected = BooleanProperty(False)
+    selectable = BooleanProperty(True)
+
+    def refresh_view_attrs(self, rv, index, data):
+        """Catch and handle the view changes"""
+        self.index = index
+        return super(SelectableLabel, self).refresh_view_attrs(rv, index, data)
+
+    def on_touch_down(self, touch):  # pylint: disable=inconsistent-return-statements
+        """Add selection on touch down"""
+        if super(SelectableLabel, self).on_touch_down(touch):
+            return True
+        if self.collide_point(*touch.pos) and self.selectable:
+            return self.parent.select_with_touch(self.index, touch)
+
+    def apply_selection(self, rv, index, is_selected):
+        """Respond to the selection of items in the view"""
+        self.selected = is_selected
+        if is_selected:
+            rv.parent.txt_input.text = rv.parent.txt_input.text.replace(
+                rv.parent.txt_input.text, rv.data[index]["text"]
+            )

src/bitmessagekivy/baseclass/myaddress.py

@@ -0,0 +1,243 @@
+# pylint: disable=import-error, no-name-in-module, too-many-ancestors, no-member, unused-argument
+# pylint: disable=import-outside-toplevel, too-many-function-args, simplifiable-if-expression
+# pylint: disable=too-few-public-methods, attribute-defined-outside-init
+"""
+Kivy My Address Book screen
+"""
+
+from functools import partial
+from kivy.clock import Clock
+from kivy.properties import (
+    ListProperty,
+    StringProperty
+)
+from kivy.uix.screenmanager import Screen
+
+
+from baseclass.common import (
+    avatarImageFirstLetter, AvatarSampleWidget, ThemeClsColor,
+    toast
+)
+from baseclass.popup import MyaddDetailPopup
+
+from kivymd.uix.button import MDFlatButton
+from kivymd.uix.dialog import MDDialog
+from kivymd.uix.label import MDLabel
+from kivymd.uix.list import (
+    IRightBodyTouch,
+    TwoLineAvatarIconListItem,
+)
+from kivymd.uix.selectioncontrol import MDSwitch
+
+from pybitmessage import state
+from pybitmessage.get_platform import platform
+from pybitmessage.bmconfigparser import config
+
+
+class ToggleBtn(IRightBodyTouch, MDSwitch):
+    """ToggleBtn class for kivy Ui"""
+
+
+class CustomTwoLineAvatarIconListItem(TwoLineAvatarIconListItem):
+    """CustomTwoLineAvatarIconListItem class for kivy Ui"""
+
+
+class BadgeText(IRightBodyTouch, MDLabel):  # pylint: disable=abstract-method
+    """BadgeText class for kivy Ui"""
+
+
+class MyAddress(Screen):
+    """MyAddress screen class for kivy Ui"""
+
+    address_label = StringProperty()
+    text_address = StringProperty()
+    addresses_list = ListProperty()
+    has_refreshed = True
+    is_add_created = False
+
+    def __init__(self, *args, **kwargs):
+        """Clock schdule for method Myaddress accounts"""
+        super(MyAddress, self).__init__(*args, **kwargs)
+        Clock.schedule_once(self.init_ui, 0)
+
+    def init_ui(self):
+        """Clock schdule for method Myaddress accounts"""
+        # pylint: disable=unnecessary-lambda
+        self.addresses_list = config.addresses()
+        if state.searcing_text:
+            self.ids.refresh_layout.scroll_y = 1.0
+            filtered_list = [
+                x for x in config.addresses()
+                if self.filter_address(x)
+            ]
+            self.addresses_list = filtered_list
+        self.addresses_list = list(reversed(self.addresses_list))
+        self.ids.tag_label.text = ''
+        if self.addresses_list:
+            self.ids.tag_label.text = 'My Addresses'
+            self.has_refreshed = True
+            self.set_mdList(0, 15)
+            self.ids.refresh_layout.bind(scroll_y=self.check_scroll_y)
+        else:
+            content = MDLabel(
+                font_style='Caption',
+                theme_text_color='Primary',
+                text="No address found!" if state.searcing_text
+                else "yet no address is created by user!!!!!!!!!!!!!",
+                halign='center',
+                size_hint_y=None,
+                valign='top')
+            self.ids.ml.add_widget(content)
+            if not state.searcing_text and not self.is_add_created:
+                try:
+                    self.manager.current = 'login'
+                except Exception:
+                    pass
+
+    def set_mdList(self, first_index, last_index):
+        """Creating the mdlist"""
+        data = []
+        for address in self.addresses_list[first_index:last_index]:
+            data.append({
+                'text': config.get(address, 'label'),
+                'secondary_text': address})
+        for item in data:
+            is_enable = config.get(item['secondary_text'], 'enabled')
+            meny = CustomTwoLineAvatarIconListItem(
+                text=item['text'], secondary_text=item['secondary_text'],
+                theme_text_color='Custom' if is_enable == 'true' else 'Primary',
+                text_color=ThemeClsColor,)
+            # meny._txt_right_pad = dp(70)
+            try:
+                meny.canvas.children[3].rgba = [0, 0, 0, 0] if is_enable == 'true' else [0.5, 0.5, 0.5, 0.5]
+            except Exception:
+                pass
+            meny.add_widget(AvatarSampleWidget(
+                source=state.imageDir + '/text_images/{}.png'.format(
+                    avatarImageFirstLetter(item['text'].strip()))))
+            meny.bind(on_press=partial(
+                self.myadd_detail, item['secondary_text'], item['text']))
+            if state.association == item['secondary_text'] and is_enable == 'true':
+                badge_obj = BadgeText(
+                    size_hint=(None, None),
+                    size=[90 if platform == 'android' else 50, 60],
+                    text='Active', halign='center',
+                    font_style='Body1', theme_text_color='Custom',
+                    text_color=ThemeClsColor
+                )
+                badge_obj.font_size = '13sp'
+                meny.add_widget(badge_obj)
+            else:
+                meny.add_widget(ToggleBtn(active=True if is_enable == 'true' else False))
+            self.ids.ml.add_widget(meny)
+
+    def check_scroll_y(self, instance, somethingelse):
+        """Load data on scroll down"""
+        if self.ids.refresh_layout.scroll_y <= -0.0 and self.has_refreshed:
+            self.ids.refresh_layout.scroll_y = 0.06
+
+    def myadd_detail(self, fromaddress, label, *args):
+        """Load myaddresses details"""
+        if config.get(fromaddress, 'enabled') == 'true':
+            obj = MyaddDetailPopup()
+            self.address_label = obj.address_label = label
+            self.text_address = obj.address = fromaddress
+            width = .9 if platform == 'android' else .6
+            # pylint: disable=attribute-defined-outside-init
+            self.myadddetail_popup = MDDialog(
+                type="custom",
+                size_hint=(width, .25),
+                content_cls=obj,
+            )
+            # self.myadddetail_popup.set_normal_height()
+            self.myadddetail_popup.auto_dismiss = False
+            self.myadddetail_popup.open()
+            # p.set_address(fromaddress, label)
+        else:
+            width = .8 if platform == 'android' else .55
+            dialog_box = MDDialog(
+                text='Address is not currently active. Please click on Toggle button to active it.',
+                size_hint=(width, .25),
+                buttons=[
+                    MDFlatButton(
+                        text="Ok", on_release=lambda x: callback_for_menu_items("Ok")
+                    ),
+                ],
+            )
+            dialog_box.open()
+
+        def callback_for_menu_items(text_item, *arg):
+            """Callback of alert box"""
+            dialog_box.dismiss()
+            toast(text_item)
+
+    def refresh_callback(self, *args):
+        """Method updates the state of application,
+        While the spinner remains on the screen"""
+        def refresh_callback(interval):
+            """Method used for loading the myaddress screen data"""
+            state.searcing_text = ''
+            # state.kivyapp.root.ids.sc10.children[2].active = False
+            self.ids.search_bar.ids.search_field.text = ''
+            self.has_refreshed = True
+            self.ids.ml.clear_widgets()
+            self.init_ui()
+            self.ids.refresh_layout.refresh_done()
+            # self.tick = 0
+            Clock.schedule_once(self.address_permision_callback, 0)
+        Clock.schedule_once(refresh_callback, 1)
+
+    @staticmethod
+    def filter_address(address):
+        """Method will filter the my address list data"""
+        if [
+                x for x in [
+                    config.get(address, 'label').lower(),
+                    address.lower()
+                ]
+                if (state.searcing_text).lower() in x
+        ]:
+            return True
+        return False
+
+    def disableAddress(self, address, instance):
+        """This method is use for disabling address"""
+        config.set(str(address), 'enabled', 'false')
+        config.save()
+        instance.parent.parent.theme_text_color = 'Primary'
+        instance.parent.parent.canvas.children[3].rgba = [0.5, 0.5, 0.5, 0.5]
+        # try:
+        #     instance.parent.parent.canvas.children[6].rgba = [0.5, 0.5, 0.5, 0.5]
+        # except Exception:
+        #     instance.parent.parent.canvas.children[9].rgba = [0.5, 0.5, 0.5, 0.5]
+        toast('Address disabled')
+        Clock.schedule_once(self.address_permision_callback, 0)
+
+    def enableAddress(self, address, instance):
+        """This method is use for enabling address"""
+        config.set(address, 'enabled', 'true')
+        config.save()
+        instance.parent.parent.theme_text_color = 'Custom'
+        instance.parent.parent.canvas.children[3].rgba = [0, 0, 0, 0]
+        # try:
+        #     instance.parent.parent.canvas.children[6].rgba = [0, 0, 0, 0]
+        # except Exception:
+        #     instance.parent.parent.canvas.children[9].rgba = [0, 0, 0, 0]
+        toast('Address Enabled')
+        Clock.schedule_once(self.address_permision_callback, 0)
+
+    def address_permision_callback(self):
+        """callback for enable or disable addresses"""
+        addresses = [addr for addr in config.addresses()
+                     if config.get(str(addr), 'enabled') == 'true']
+        self.parent.parent.ids.content_drawer.ids.btn.values = addresses
+        self.parent.parent.ids.sc3.children[1].ids.btn.values = addresses
+        state.kivyapp.variable_1 = addresses
+
+    def toggleAction(self, instance):
+        """This method is used for enable or disable address"""
+        addr = instance.parent.parent.secondary_text
+        if instance.active:
+            self.enableAddress(addr, instance)
+        else:
+            self.disableAddress(addr, instance)

src/bitmessagekivy/baseclass/network.py

@@ -0,0 +1,32 @@
+# pylint: disable=consider-using-f-string, no-name-in-module, too-few-public-methods
+
+"""
+Kivy Network screen
+"""
+
+from kivy.clock import Clock
+from kivy.properties import StringProperty
+from kivy.uix.screenmanager import Screen
+
+
+class NetworkStat(Screen):
+    """NetworkStat class for kivy Ui"""
+
+    text_variable_1 = StringProperty(
+        '{0}::{1}'.format('Total Connections', '0'))
+    text_variable_2 = StringProperty(
+        'Processed {0} per-to-per messages'.format('0'))
+    text_variable_3 = StringProperty(
+        'Processed {0} brodcast messages'.format('0'))
+    text_variable_4 = StringProperty(
+        'Processed {0} public keys'.format('0'))
+    text_variable_5 = StringProperty(
+        'Processed {0} object to be synced'.format('0'))
+
+    def __init__(self, *args, **kwargs):
+        """Init method for network stat"""
+        super(NetworkStat, self).__init__(*args, **kwargs)
+        Clock.schedule_interval(self.init_ui, 1)
+
+    def init_ui(self, dt=0):
+        """Clock Schdule for method networkstat screen"""

src/bitmessagekivy/baseclass/payment.py

@@ -0,0 +1,44 @@
+# pylint: disable=too-many-ancestors, abstract-method, too-few-public-methods
+
+'''
+    This is for pamyent related part
+'''
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.screenmanager import Screen
+from kivymd.uix.behaviors.elevation import RectangularElevationBehavior
+
+from kivymd.uix.label import MDLabel
+from kivymd.uix.list import (
+    IRightBodyTouch,
+    OneLineAvatarIconListItem
+)
+
+
+class Payment(Screen):
+    """Payment Screen class for kivy Ui"""
+
+    @staticmethod
+    def create_hidden_payment_address():
+        """This is basically used for creating hidden address used in payment for purchasing credits"""
+
+
+class Category(BoxLayout, RectangularElevationBehavior):
+    """Category class for kivy Ui"""
+    elevation_normal = .01
+
+
+class ProductLayout(BoxLayout, RectangularElevationBehavior):
+    """ProductLayout class for kivy Ui"""
+    elevation_normal = .01
+
+
+class PaymentMethodLayout(BoxLayout):
+    """PaymentMethodLayout class for kivy Ui"""
+
+
+class ListItemWithLabel(OneLineAvatarIconListItem):
+    """ListItemWithLabel class for kivy Ui"""
+
+
+class RightLabel(IRightBodyTouch, MDLabel):
+    """RightLabel class for kivy Ui"""

src/bitmessagekivy/baseclass/popup.py

@@ -0,0 +1,155 @@
+# pylint: disable=import-error, no-name-in-module, import-outside-toplevel
+# pylint: disable=too-few-public-methods, attribute-defined-outside-init
+
+
+"""
+Kivy All common pop managed here
+"""
+
+from datetime import datetime
+
+from kivy.clock import Clock
+from kivy.metrics import dp
+from kivy.properties import StringProperty
+from kivy.uix.popup import Popup
+from kivy.uix.boxlayout import BoxLayout
+
+from baseclass.common import toast
+
+from pybitmessage import state
+
+
+platform = "linux"
+
+
+class LoadingPopup(Popup):
+    """LoadingPopup class for kivy Ui"""
+
+    def __init__(self, **kwargs):
+        super(LoadingPopup, self).__init__(**kwargs)
+        # call dismiss_popup in 2 seconds
+        Clock.schedule_once(self.dismiss_popup, 0.5)
+
+    def dismiss_popup(self):
+        """Dismiss popups"""
+        self.dismiss()
+
+
+class GrashofPopup(BoxLayout):
+    """GrashofPopup class for kivy Ui"""
+
+    valid = False
+
+    def checkAddress_valid(self, instance):
+        """Checking address is valid or not"""
+
+    def checkLabel_valid(self, instance):
+        """Checking address label is unique or not"""
+
+    def _onSuccess(self, addressVersion, streamNumber, ripe):
+        """Called when the popup is open"""
+
+
+class AddbookDetailPopup(BoxLayout):
+    """AddbookDetailPopup class for kivy Ui"""
+
+    address_label = StringProperty()
+    address = StringProperty()
+
+    def checkLabel_valid(self, instance):
+        """Checking address label is unique of not"""
+        entered_label = str(instance.text.strip())
+        address_list = []
+        addr_labels = [labels[0] for labels in address_list]
+        add_dict = dict(address_list)
+        if self.address and entered_label in addr_labels \
+                and self.address != add_dict[entered_label]:
+            self.ids.add_label.error = True
+            self.ids.add_label.helper_text = 'label name already exists.'
+        elif entered_label:
+            self.ids.add_label.error = False
+        else:
+            self.ids.add_label.error = False
+            self.ids.add_label.helper_text = 'This field is required'
+
+
+class MyaddDetailPopup(BoxLayout):
+    """MyaddDetailPopup class for kivy Ui"""
+
+    address_label = StringProperty()
+    address = StringProperty()
+
+    def send_message_from(self):
+        """Method used to fill from address of composer autofield"""
+        state.kivyapp.set_navbar_for_composer()
+        window_obj = state.kivyapp.root.ids
+        window_obj.sc3.children[1].ids.ti.text = self.address
+        window_obj.sc3.children[1].ids.btn.text = self.address
+        window_obj.sc3.children[1].ids.txt_input.text = ''
+        window_obj.sc3.children[1].ids.subject.text = ''
+        window_obj.sc3.children[1].ids.body.text = ''
+        window_obj.scr_mngr.current = 'create'
+        self.parent.parent.parent.dismiss()
+
+    # @staticmethod
+    def close_pop(self):
+        """Pop is Canceled"""
+        self.parent.parent.parent.dismiss()
+        toast('Canceled')
+
+
+class AppClosingPopup(Popup):
+    """AppClosingPopup class for kivy Ui"""
+
+    def closingAction(self, text):
+        """Action on closing window"""
+        if text == 'Yes':
+            print("*******************EXITING FROM APPLICATION*******************")
+            from pybitmessage import shutdown
+            shutdown.doCleanShutdown()
+        else:
+            self.dismiss()
+            toast(text)
+
+
+class SenderDetailPopup(Popup):
+    """SenderDetailPopup class for kivy Ui"""
+
+    to_addr = StringProperty()
+    from_addr = StringProperty()
+    time_tag = StringProperty()
+
+    def assignDetail(self, to_addr, from_addr, timeinseconds):
+        """Detailes assigned"""
+        self.to_addr = to_addr
+        self.from_addr = from_addr
+        time_obj = datetime.fromtimestamp(int(timeinseconds))
+        self.time_tag = time_obj.strftime("%d %b %Y, %I:%M %p")
+        device_type = 2 if platform == 'android' else 1.5
+        pop_height = 1.2 * device_type * (self.ids.sd_label.height + self.ids.dismiss_btn.height)
+        if len(to_addr) > 3:
+            self.height = pop_height
+            self.ids.to_addId.size_hint_y = None
+            self.ids.to_addId.height = 50
+            self.ids.to_addtitle.add_widget(ToAddressTitle())
+            frmaddbox = ToAddrBoxlayout()
+            frmaddbox.set_toAddress(to_addr)
+            self.ids.to_addId.add_widget(frmaddbox)
+        else:
+            self.ids.space_1.height = dp(0)
+            self.ids.space_2.height = dp(0)
+            self.ids.myadd_popup_box.spacing = dp(8 if platform == 'android' else 3)
+            self.height = pop_height / 1.2
+
+
+class ToAddrBoxlayout(BoxLayout):
+    """ToAddrBoxlayout class for kivy Ui"""
+    to_addr = StringProperty()
+
+    def set_toAddress(self, to_addr):
+        """This method is use to set to address"""
+        self.to_addr = to_addr
+
+
+class ToAddressTitle(BoxLayout):
+    """ToAddressTitle class for BoxLayout behaviour"""

src/bitmessagekivy/baseclass/qrcode.py

@@ -0,0 +1,26 @@
+# pylint: disable=import-error, no-name-in-module, too-few-public-methods
+
+"""
+QRCode generator
+"""
+
+from kivy.uix.screenmanager import Screen
+from kivy.properties import StringProperty
+from kivy_garden.qrcode import QRCodeWidget
+from baseclass.common import toast
+from pybitmessage import state
+
+
+class ShowQRCode(Screen):
+    """ShowQRCode Screen class for kivy Ui"""
+    address = StringProperty()
+
+    def qrdisplay(self, instasnce, address):
+        """Method used for showing QR Code"""
+        self.ids.qr.clear_widgets()
+        state.kivyapp.set_toolbar_for_QrCode()
+        self.address = address
+        self.ids.qr.add_widget(QRCodeWidget(data=address))
+        self.ids.qr.children[0].show_border = False
+        instasnce.parent.parent.parent.dismiss()
+        toast('Show QR code')

src/bitmessagekivy/baseclass/scan_screen.py

@@ -0,0 +1,104 @@
+# pylint: disable=import-error, no-name-in-module, import-outside-toplevel, arguments-differ
+
+"""
+Kivy QR Scan screen
+"""
+
+import os
+
+from kivy.clock import Clock
+from kivy.lang import Builder
+from kivy.properties import (
+    BooleanProperty,
+    ObjectProperty,
+    StringProperty
+)
+from kivy.uix.screenmanager import Screen
+
+from pybitmessage.get_platform import platform
+
+
+class ScanScreen(Screen):
+    """ScanScreen is for scaning Qr code"""
+    # pylint: disable=unused-argument
+    # pylint: disable=W0212
+    camera_avaialbe = BooleanProperty(False)
+    previous_open_screen = StringProperty()
+    pop_up_instance = ObjectProperty()
+
+    def __init__(self, *args, **kwargs):
+        """Getting AddressBook Details"""
+        super(ScanScreen, self).__init__(*args, **kwargs)
+        self.check_camera()
+
+    def check_camera(self):
+        """This method is used for checking camera avaibility"""
+        if platform != "android":
+            import cv2
+            cap = cv2.VideoCapture(0)  # pylint: disable=no-member
+            while cap.isOpened():
+                print('Camera is available!')
+                self.camera_avaialbe = True
+                break
+            else:
+                print("Camera is not available!")
+                self.camera_avaialbe = False
+        else:
+            self.camera_avaialbe = True
+
+    def get_screen(self, screen_name, instance=None):
+        """This method is used for getting previous screen name"""
+        self.previous_open_screen = screen_name
+        if screen_name != 'composer':
+            self.pop_up_instance = instance
+
+    def on_pre_enter(self):
+        """
+       on_pre_enter works little better on android
+       It affects screen transition on linux
+       """
+        if not self.children:
+            tmp = Builder.load_file(
+                os.path.join(
+                    os.path.dirname(os.path.dirname(__file__)), "kv/{}.kv").format("scanner")
+            )
+            self.add_widget(tmp)
+        if platform == "android":
+            Clock.schedule_once(self.start_camera, 0)
+
+    def on_enter(self):
+        """
+       on_enter works better on linux
+       It creates a black screen on android until camera gets loaded
+       """
+        # print(self.children)
+        if platform != "android":
+            # pass
+            Clock.schedule_once(self.start_camera, 0)
+
+    def on_leave(self):
+        """this methos will call on leave"""
+        # pass
+        Clock.schedule_once(self.stop_camera, 0)
+
+    def start_camera(self, *args):
+        """Its used for starting camera for scanning qrcode"""
+        # pylint: disable=attribute-defined-outside-init
+        self.xcam = self.children[0].ids.zbarcam.ids.xcamera
+        if platform == "android":
+            self.xcam.play = True
+
+        else:
+            Clock.schedule_once(self.open_cam, 0)
+
+    def stop_camera(self, *args):
+        """Its used for stop the camera"""
+        self.xcam.play = False
+        if platform != "android":
+            self.xcam._camera._device.release()
+
+    def open_cam(self, *args):
+        """It will open up the camera"""
+        if not self.xcam._camera._device.isOpened():
+            self.xcam._camera._device.open(self.xcam._camera._index)
+        self.xcam.play = True

src/bitmessagekivy/baseclass/sent.py

@@ -0,0 +1,179 @@
+# pylint: disable=import-error, no-name-in-module, consider-using-f-string
+# pylint: disable=simplifiable-if-expression, pointless-statement,  no-member
+
+"""
+Kivy Sent box screen
+"""
+
+from functools import partial
+
+from kivy.clock import Clock
+from kivy.properties import StringProperty, ListProperty
+from kivy.uix.screenmanager import Screen
+
+
+from baseclass.common import (
+    showLimitedCnt, ThemeClsColor, avatarImageFirstLetter,
+    toast, SwipeToDeleteItem, ShowTimeHistoy
+)
+
+from kivymd.uix.label import MDLabel
+
+from pybitmessage import state
+from pybitmessage import kivy_state
+
+
+class Sent(Screen):
+    """Sent Screen class for kivy Ui"""
+
+    queryreturn = ListProperty()
+    has_refreshed = True
+    account = StringProperty()
+
+    def __init__(self, *args, **kwargs):
+        """Association with the screen"""
+        super(Sent, self).__init__(*args, **kwargs)
+        if state.association == '':
+            if state.kivyapp.variable_1:
+                state.association = state.kivyapp.variable_1[0]
+        Clock.schedule_once(self.init_ui, 0)
+
+    def init_ui(self, dt=0):
+        """Clock Schdule for method sent accounts"""
+        self.loadSent()
+        print(dt)
+
+    def loadSent(self):
+        """Load Sent list for Sent messages"""
+        self.account = state.association
+        if kivy_state.searcing_text:
+            self.ids.scroll_y.scroll_y = 1.0
+        data = []
+        self.ids.tag_label.text = ''
+        if self.queryreturn:
+            self.ids.tag_label.text = 'Sent'
+            self.set_sentCount(kivy_state.sent_count)
+            for mail in self.queryreturn:
+                data.append({
+                    'text': mail[1].strip(),
+                    'secondary_text': (mail[2][:50] + '........' if len(
+                        mail[2]) >= 50 else (mail[2] + ',' + mail[3])[0:50] + '........').replace(
+                            '\t', '').replace('  ', ''),
+                    'ackdata': mail[5], 'senttime': mail[6]},)
+            self.set_mdlist(data, 0)
+            self.has_refreshed = True
+            self.ids.scroll_y.bind(scroll_y=self.check_scroll_y)
+        else:
+            self.set_sentCount('0')
+            content = MDLabel(
+                font_style='Caption',
+                theme_text_color='Primary',
+                text="No message found!" if kivy_state.searcing_text
+                else "yet no message for this account!!!!!!!!!!!!!",
+                halign='center',
+                size_hint_y=None,
+                valign='top')
+            self.ids.ml.add_widget(content)
+
+    def set_mdlist(self, data, set_index=0):
+        """This method is used to create the mdList"""
+        total_sent_msg = len(self.ids.ml.children)
+        for item in data:
+            message_row = SwipeToDeleteItem(
+                text=item["text"],
+            )
+            listItem = message_row.ids.content
+            listItem.secondary_text = item["secondary_text"]
+            listItem.theme_text_color = "Custom"
+            listItem.text_color = ThemeClsColor
+            image = kivy_state.imageDir + '/text_images/{}.png'.format(
+                avatarImageFirstLetter(item['secondary_text'].strip()))
+            message_row.ids.avater_img.source = image
+            listItem.bind(on_release=partial(self.sent_detail, item['ackdata'], message_row))
+            message_row.ids.time_tag.text = str(ShowTimeHistoy(item['senttime']))
+            message_row.ids.delete_msg.bind(on_press=partial(self.delete, item["ackdata"]))
+            self.ids.ml.add_widget(message_row, index=set_index)
+
+        updated_msgs = len(self.ids.ml.children)
+        self.has_refreshed = True if total_sent_msg != updated_msgs else False
+
+    def update_sent_messagelist(self):
+        """This method is used to update screen when new mail is sent"""
+        self.account = state.association
+        if len(self.ids.ml.children) < 3:
+            self.ids.ml.clear_widgets()
+            self.loadSent()
+            if state.association == kivy_state.check_sent_acc:
+                total_sent = int(kivy_state.sent_count) + 1
+                kivy_state.sent_count = str(int(kivy_state.sent_count) + 1)
+                self.set_sentCount(total_sent)
+            else:
+                total_sent = int(kivy_state.sent_count)
+        else:
+            data = []
+            if state.association == kivy_state.check_sent_acc:
+                total_sent = int(kivy_state.sent_count) + 1
+                kivy_state.sent_count = str(int(kivy_state.sent_count) + 1)
+                self.set_sentCount(total_sent)
+            else:
+                total_sent = int(kivy_state.sent_count)
+            for mail in self.queryreturn:
+                data.append({
+                    'text': mail[1].strip(),
+                    'secondary_text': (mail[2][:50] + '........' if len(
+                        mail[2]) >= 50 else (mail[2] + ',' + mail[3])[0:50] + '........').replace(
+                            '\t', '').replace('  ', ''),
+                    'ackdata': mail[5], 'senttime': mail[6]})
+            self.set_mdlist(data, total_sent - 1)
+        if kivy_state.msg_counter_objs and state.association == (
+                kivy_state.check_sent_acc):
+            kivy_state.all_count = str(int(kivy_state.all_count) + 1)
+            kivy_state.msg_counter_objs.allmail_cnt.badge_text = kivy_state.all_count
+            kivy_state.check_sent_acc = None
+
+    def check_scroll_y(self):
+        """Load data on scroll down"""
+        if self.ids.scroll_y.scroll_y <= -0.0 and self.has_refreshed:
+            self.ids.scroll_y.scroll_y = 0.06
+
+    @staticmethod
+    def set_sentCount(total_sent):
+        """Set the total no. of sent message count"""
+        src_mng_obj = state.kivyapp.root.ids.content_drawer.ids.send_cnt
+        state.kivyapp.root.ids.content_drawer.ids.send_cnt.ids.badge_txt.text
+        if state.association:
+            src_mng_obj.ids.badge_txt.text = showLimitedCnt(int(total_sent))
+        else:
+            src_mng_obj.ids.badge_txt.text = '0'
+
+    def sent_detail(self, ackdata, instance):
+        """Load sent mail details"""
+        if instance.state == 'closed':
+            instance.ids.delete_msg.disabled = True
+            if instance.open_progress == 0.0:
+                kivy_state.detailPageType = 'sent'
+                kivy_state.mail_id = ackdata
+                if self.manager:
+                    src_mng_obj = self.manager
+                else:
+                    src_mng_obj = self.parent.parent
+                src_mng_obj.screens[11].clear_widgets()
+                # src_mng_obj.screens[11].add_widget(MailDetail())
+                src_mng_obj.current = 'mailDetail'
+        else:
+            instance.ids.delete_msg.disabled = False
+
+    def delete(self, instance):
+        """Delete sent mail from sent mail listing"""
+        msg_count_objs = self.parent.parent.ids.content_drawer.ids
+        if int(kivy_state.sent_count) > 0:
+            msg_count_objs.send_cnt.ids.badge_txt.text = showLimitedCnt(int(kivy_state.sent_count) - 1)
+            msg_count_objs.trash_cnt.ids.badge_txt.text = showLimitedCnt(int(kivy_state.trash_count) + 1)
+            msg_count_objs.allmail_cnt.ids.badge_txt.text = showLimitedCnt(int(kivy_state.all_count) - 1)
+            kivy_state.sent_count = str(int(kivy_state.sent_count) - 1)
+            kivy_state.trash_count = str(int(kivy_state.trash_count) + 1)
+            kivy_state.all_count = str(int(kivy_state.all_count) - 1)
+            if int(kivy_state.sent_count) <= 0:
+                self.ids.tag_label.text = ''
+        self.ids.ml.remove_widget(instance.parent.parent)
+        toast('Deleted')

src/bitmessagekivy/baseclass/settings.py

@@ -0,0 +1,10 @@
+# pylint: disable=too-few-public-methods
+
+"""
+App Settings Screen
+"""
+from kivy.uix.screenmanager import Screen
+
+
+class Setting(Screen):
+    """Setting Screen for kivy Ui"""

src/bitmessagekivy/baseclass/trash.py

@@ -0,0 +1,79 @@
+# pylint: disable=import-error, no-name-in-module, simplifiable-if-expression, no-self-use
+
+"""
+Kivy Trash Box screen
+"""
+
+from kivy.clock import Clock
+from kivy.properties import (
+    ListProperty,
+    StringProperty
+)
+from kivy.uix.screenmanager import Screen
+
+from baseclass.common import showLimitedCnt
+
+
+from kivymd.uix.label import MDLabel
+
+from pybitmessage import state
+from pybitmessage import kivy_state
+
+
+class Trash(Screen):
+    """Trash Screen class for kivy Ui"""
+
+    trash_messages = ListProperty()
+    has_refreshed = True
+    delete_index = None
+    table_name = StringProperty()
+
+    def __init__(self, *args, **kwargs):
+        """Trash method, delete sent message and add in Trash"""
+        super(Trash, self).__init__(*args, **kwargs)
+        Clock.schedule_once(self.init_ui, 0)
+
+    def init_ui(self):
+        """Clock Schdule for method trash screen"""
+        if state.association == '':
+            if state.kivyapp.variable_1:
+                state.association = state.kivyapp.variable_1[0]
+        self.ids.tag_label.text = ''
+        if len(self.trash_messages):
+            self.ids.ml.clear_widgets()
+            self.ids.tag_label.text = 'Trash'
+            # src_mng_obj = state.kivyapp.root.children[2].children[0].ids
+            # src_mng_obj.trash_cnt.badge_text = state.trash_count
+            self.set_TrashCnt(kivy_state.trash_count)
+            self.set_mdList()
+            self.ids.scroll_y.bind(scroll_y=self.check_scroll_y)
+        else:
+            self.set_TrashCnt('0')
+            content = MDLabel(
+                font_style='Caption',
+                theme_text_color='Primary',
+                text="yet no trashed message for this account!!!!!!!!!!!!!",
+                halign='center',
+                size_hint_y=None,
+                valign='top')
+            self.ids.ml.add_widget(content)
+
+    def set_TrashCnt(self, Count):
+        """This method is used to set trash message count"""
+        trashCnt_obj = state.kivyapp.root.ids.content_drawer.ids.trash_cnt
+        trashCnt_obj.ids.badge_txt.text = showLimitedCnt(int(Count))
+
+    def set_mdList(self):
+        """This method is used to create the mdlist"""
+        total_trash_msg = len(self.ids.ml.children)
+        self.has_refreshed = True if total_trash_msg != len(
+            self.ids.ml.children) else False
+
+    def on_swipe_complete(self, instance):
+        """call on swipe left"""
+        instance.ids.delete_msg.disabled = bool(instance.state == 'closed')
+
+    def check_scroll_y(self):
+        """Load data on scroll"""
+        if self.ids.scroll_y.scroll_y <= -0.0 and self.has_refreshed:
+            self.ids.scroll_y.scroll_y = 0.06

src/bitmessageqt/__init__.py

@@ -1674,7 +1674,8 @@ class MyForm(settingsmixin.SMainWindow):
             self.ui.blackwhitelist.init_blacklist_popup_menu(False)
         if event.type() == QtCore.QEvent.WindowStateChange:
             if self.windowState() & QtCore.Qt.WindowMinimized:
-                if config.getboolean('bitmessagesettings', 'minimizetotray') and not 'darwin' in sys.platform:
+                if config.getboolean(
+                        'bitmessagesettings', 'minimizetotray') and not 'darwin' in sys.platform:
                     QtCore.QTimer.singleShot(0, self.appIndicatorHide)
             elif event.oldState() & QtCore.Qt.WindowMinimized:
                 # The window state has just been changed to
@@ -3058,7 +3059,8 @@ class MyForm(settingsmixin.SMainWindow):
         queryreturn = sqlQuery('''select * from blacklist where address=?''',
                                addressAtCurrentInboxRow)
         if queryreturn == []:
-            label = "\"" + tableWidget.item(currentInboxRow, 2).subject + "\" in " + config.get(
+            label = "\"" + tableWidget.item(
+                currentInboxRow, 2).subject + "\" in " + config.get(
                 recipientAddress, "label")
             sqlExecute('''INSERT INTO blacklist VALUES (?,?, ?)''',
                        label,