309 lines
12 KiB
Python
309 lines
12 KiB
Python
import time
|
|
|
|
from bitmessagekivy.get_platform import platform
|
|
from bmconfigparser import BMConfigParser
|
|
from helper_sql import sqlExecute, sqlQuery
|
|
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 kivymd.uix.button import MDFlatButton
|
|
from kivymd.uix.dialog import MDDialog
|
|
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 kivy.uix.textinput import TextInput
|
|
|
|
import state
|
|
import queues
|
|
|
|
from addresses import decodeAddress
|
|
from bitmessagekivy.baseclass.common import (
|
|
toast, showLimitedCnt
|
|
)
|
|
|
|
|
|
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 = [
|
|
addr[1] for addr in sqlQuery(
|
|
"SELECT label, address from addressbook")]
|
|
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"""
|
|
|
|
def __init__(self, **kwargs):
|
|
"""Recycling Method"""
|
|
super(RV, self).__init__(**kwargs)
|
|
|
|
|
|
class SelectableRecycleBoxLayout(
|
|
FocusBehavior, LayoutSelectionBehavior, RecycleBoxLayout
|
|
):
|
|
"""Adds selection and focus behaviour to the view"""
|
|
|
|
# pylint: disable = duplicate-bases
|
|
|
|
|
|
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()
|
|
encoding = 3
|
|
print("message: ", self.ids.body.text)
|
|
sendMessageToPeople = True
|
|
if sendMessageToPeople:
|
|
if toAddress != "" and subject and message:
|
|
status, addressVersionNumber, streamNumber, ripe = decodeAddress(
|
|
toAddress
|
|
)
|
|
if status == "success":
|
|
navApp.root.ids.sc3.children[0].active = True
|
|
if state.detailPageType == "draft" and state.send_draft_mail:
|
|
sqlExecute(
|
|
"UPDATE sent SET toaddress = ?"
|
|
", fromaddress = ? , subject = ?"
|
|
", message = ?, folder = 'sent'"
|
|
", senttime = ?, lastactiontime = ?"
|
|
" WHERE ackdata = ?;",
|
|
toAddress,
|
|
fromAddress,
|
|
subject,
|
|
message,
|
|
int(time.time()),
|
|
int(time.time()),
|
|
state.send_draft_mail)
|
|
self.parent.parent.screens[13].clear_widgets()
|
|
self.parent.parent.screens[13].add_widget(Factory.Draft())
|
|
# state.detailPageType = ''
|
|
# state.send_draft_mail = None
|
|
else:
|
|
from addresses import addBMIfNotPresent
|
|
toAddress = addBMIfNotPresent(toAddress)
|
|
statusIconColor = 'red'
|
|
if (addressVersionNumber > 4) or (
|
|
addressVersionNumber <= 1):
|
|
print(
|
|
"addressVersionNumber > 4"
|
|
" or addressVersionNumber <= 1")
|
|
if streamNumber > 1 or streamNumber == 0:
|
|
print("streamNumber > 1 or streamNumber == 0")
|
|
if statusIconColor == 'red':
|
|
print("shared.statusIconColor == 'red'")
|
|
stealthLevel = BMConfigParser().safeGetInt(
|
|
'bitmessagesettings', 'ackstealthlevel')
|
|
from helper_ackPayload import genAckPayload
|
|
ackdata = genAckPayload(streamNumber, stealthLevel)
|
|
# t = ()
|
|
sqlExecute(
|
|
'''INSERT INTO sent VALUES
|
|
(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)''',
|
|
'',
|
|
toAddress,
|
|
ripe,
|
|
fromAddress,
|
|
subject,
|
|
message,
|
|
ackdata,
|
|
int(time.time()),
|
|
int(time.time()),
|
|
0,
|
|
'msgqueued',
|
|
0,
|
|
'sent',
|
|
encoding,
|
|
BMConfigParser().safeGetInt(
|
|
'bitmessagesettings', 'ttl'))
|
|
state.check_sent_acc = fromAddress
|
|
# state.msg_counter_objs = self.parent.parent.parent.parent\
|
|
# .parent.parent.children[2].children[0].ids
|
|
if state.detailPageType == 'draft' \
|
|
and state.send_draft_mail:
|
|
state.draft_count = str(int(state.draft_count) - 1)
|
|
# state.msg_counter_objs.draft_cnt.badge_text = (
|
|
# state.draft_count)
|
|
state.detailPageType = ''
|
|
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(state.all_count) + 1)
|
|
state.all_count = str(int(state.all_count) + 1)
|
|
Clock.schedule_once(self.callback_for_msgsend, 3)
|
|
queues.workerQueue.put(('sendmessage', toAddress))
|
|
print("sqlExecute successfully #######################")
|
|
state.in_composer = True
|
|
return
|
|
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):
|
|
"""Callback method for messagesend"""
|
|
state.kivyapp.root.ids.sc3.children[0].active = False
|
|
state.in_sent_method = True
|
|
state.kivyapp.back_press()
|
|
toast("sent")
|
|
|
|
def address_error_message(self, 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):
|
|
self.parent.parent.parent.ids.sc23.check_camera()
|
|
is_available = self.parent.parent.parent.ids.sc23.camera_avaialbe
|
|
return is_available
|
|
|
|
def camera_alert(self):
|
|
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(TextInput):
|
|
"""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):
|
|
"""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:
|
|
print("selection changed to {0}".format(rv.data[index]))
|
|
rv.parent.txt_input.text = rv.parent.txt_input.text.replace(
|
|
rv.parent.txt_input.text, rv.data[index]["text"]
|
|
)
|