Bitmessage/PyBitmessage-2024-12-09
Archived
2
0
Fork 0
Code Issues 168 Pull Requests 53 Actions Packages Projects Releases 5 Wiki Activity

Added Kivy [bitmessagekivy/baseclass]

Browse Source
This commit is contained in:
shekhar-cis 2022-02-16 13:18:15 +05:30
parent 59deb75059
commit f1bfc89ef4
Signed by untrusted user: shekhar-cis
GPG Key ID: F4F00AB04E83F9A7
19 changed files with 2155 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
src/bitmessagekivy/baseclass/__init__.py Normal file
View File

148
src/bitmessagekivy/baseclass/addressbook.py Normal file
View File

@ -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()

152
src/bitmessagekivy/baseclass/allmail.py Normal file
View File

@ -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')

125
src/bitmessagekivy/baseclass/common.py Normal file
View File

@ -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)

156
src/bitmessagekivy/baseclass/draft.py Normal file
View File

@ -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')

81
src/bitmessagekivy/baseclass/inbox.py Normal file
View File

@ -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

119
src/bitmessagekivy/baseclass/login.py Normal file
View File

@ -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

238
src/bitmessagekivy/baseclass/maildetail.py Normal file
View File

@ -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)

260
src/bitmessagekivy/baseclass/msg_composer.py Normal file
View File

@ -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"]
)

243
src/bitmessagekivy/baseclass/myaddress.py Normal file
View File

@ -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)

32
src/bitmessagekivy/baseclass/network.py Normal file
View File

@ -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"""

44
src/bitmessagekivy/baseclass/payment.py Normal file
View File

@ -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"""

155
src/bitmessagekivy/baseclass/popup.py Normal file
View File

@ -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"""

26
src/bitmessagekivy/baseclass/qrcode.py Normal file
View File

@ -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')

104
src/bitmessagekivy/baseclass/scan_screen.py Normal file
View File

@ -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

179
src/bitmessagekivy/baseclass/sent.py Normal file
View File

@ -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')

10
src/bitmessagekivy/baseclass/settings.py Normal file
View File

@ -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"""

79
src/bitmessagekivy/baseclass/trash.py Normal file
View File

@ -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

6
src/bitmessageqt/__init__.py
View File

@ -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,