class RootView(BoxLayout):
def __init__(self, *args, **kwargs):
super(RootView, self).__init__(*args, **kwargs)
self.message_handler = MessageHandler(self)
self.serial = None
self.last_serial_choices = set()
self.update_serial_choices()
def on_message(self, msg):
self.message_handler.handle(bytes(msg))
def on_serial_choice(self, checkbox, value):
if self.serial is not None:
if self.serial.port == checkbox.port:
return
self.serial.close()
self.serial = None
if value:
self.serial = SerialBindings(checkbox.port,
self.on_message)
def update_serial_choices(self, *largs):
extra_mac_ports = set(glob.glob('/dev/tty.usbserial*'))
new_serial_choices = set([port for port, _, _ in comports()])
for i_hate_macs in extra_mac_ports:
new_serial_choices.add(i_hate_macs)
if not sets_equal(self.last_serial_choices, new_serial_choices):
self.indicators.serial_choices.clear_widgets()
self.last_serial_choices = new_serial_choices
for port in sorted(list(new_serial_choices)):
port_name = port
if port_name.startswith('/dev/'):
port_name = port[5:]
btn = Builder.load_string('''
CheckBox:
size_hint_y: 1
group: 'serial_choice_group'
''')
lbl = Builder.load_string('''
SaneLabel:
size_hint_y: 1
text: '%s'
''' % (port_name,))
btn.bind(active=self.on_serial_choice)
btn.port = port
if self.serial is not None and self.serial.port == port:
btn.active = True
self.indicators.serial_choices.add_widget(btn)
self.indicators.serial_choices.add_widget(lbl)
def _handle_server_response(self, response):
"""
Handles server response. Passes raw response from server to MessageHandler and except that MessageHandler.handle returns instance of IrcEvent class, so ircbot knows what to do next with the event.
"""
message_handler = MessageHandler()
event = message_handler.handle(response)
if event and event.to_server:
for irc_message in event.to_server:
self._send_to_server(irc_message.get_command())
class Client(wx.Frame):
def __init__(self, kakopts):
super(Client, self).__init__(None)
self.Bind(wx.EVT_CLOSE, self.OnExit)
self.makeMenuBar()
self.CreateStatusBar()
self.status_line = wx.TextCtrl(self,
style=wx.TE_MULTILINE | wx.TE_READONLY
| wx.TE_RICH)
self.buffer_view = FacedStaticText(self)
self.buffer_view.Bind(wx.EVT_SIZE, self.OnBufferSize)
self.buffer_view.Bind(wx.EVT_KEY_DOWN, self.OnBufferKeyPress)
self.buffer_view.Bind(wx.EVT_CHAR, self.OnBufferChar)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.status_line, 0, wx.EXPAND)
sizer.Add(self.buffer_view, 1, wx.EXPAND)
sizer.SetSizeHints(self)
self.SetSizerAndFit(sizer)
self.kakoune = Kakoune(**kakopts)
self.kakoune.start()
self.message_handler = MessageHandler(self)
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.kakoune_tick, self.timer)
self.timer.Start(10)
self.Size = (600, 800)
def kakoune_tick(self, event):
if not self.kakoune.is_running():
self.Close()
else:
self.message_handler.handle(self.kakoune.get_next_message())
def refresh_buffer_dimensions(self):
w, h = self.buffer_view.compute_dimensions()
self.kakoune.send_resize(h, w)
def register_menu_view(self, menu_bar):
bindings = []
menu = wx.Menu()
item_zoom_in = menu.Append(wx.ID_ANY, "Zoom &in\tCtrl-+",
"Zoom buffer in")
bindings.append((item_zoom_in, self.menu_view_zoom_in))
item_zoom_out = menu.Append(wx.ID_ANY, "Zoom &out\tCtrl--",
"Zoom buffer out")
bindings.append((item_zoom_out, self.menu_view_zoom_out))
item_zoom_0 = menu.Append(wx.ID_ANY, "Zoom &reset\tCtrl-0",
"Reset buffer zoom")
bindings.append((item_zoom_0, self.menu_view_zoom_0))
menu.AppendSeparator()
menu_bar.Append(menu, "&View")
return bindings
def menu_view_zoom_in(self, event):
self.buffer_view.change_font_size('+')
self.refresh_buffer_dimensions()
def menu_view_zoom_out(self, event):
self.buffer_view.change_font_size('-')
self.refresh_buffer_dimensions()
def menu_view_zoom_0(self, event):
self.buffer_view.change_font_size('0')
self.refresh_buffer_dimensions()
def makeMenuBar(self):
menu_file = wx.Menu()
menu_file.AppendSeparator()
exitItem = menu_file.Append(wx.ID_EXIT)
helpMenu = wx.Menu()
aboutItem = helpMenu.Append(wx.ID_ABOUT)
menu_bindings = []
menuBar = wx.MenuBar()
menuBar.Append(menu_file, "&File")
menu_bindings += self.register_menu_view(menuBar)
menuBar.Append(helpMenu, "&Help")
self.SetMenuBar(menuBar)
self.Bind(wx.EVT_MENU, self.OnExit, exitItem)
self.Bind(wx.EVT_MENU, self.OnAbout, aboutItem)
for item, handler in menu_bindings:
self.Bind(wx.EVT_MENU, handler, item)
def OnBufferSize(self, event):
self.refresh_buffer_dimensions()
def OnBufferKeyPress(self, event: wx.KeyEvent):
key = wx_to_kakoune_keys.get(event.KeyCode)
if key:
#print("KEY", key)
if event.altDown:
key = alt_key(key)
self.kakoune.send_keys(key)
else:
event.Skip()
def OnBufferChar(self, event: wx.KeyEvent):
keycode = f"{event.UnicodeKey:c}"
key = wx_to_kakoune_keys.get(event.UnicodeKey, keycode)
#print("CHAR", keycode, event.UnicodeKey, keys)
if event.altDown:
key = alt_key(key)
self.kakoune.send_keys(key)
event.Skip()
def OnExit(self, event):
self.kakoune.stop()
self.Destroy()
def OnAbout(self, event):
wx.MessageBox("An experimental Kakoune GUI", "kwax",
wx.OK | wx.ICON_INFORMATION)
class ChatBotHandler(AbstracHandler):
def __init__(self, botId, botName, client, socket_delay=1):
self.botId = botId
self.botName = botName
self.mention = self.getMention(botId)
self.client = client
self.delay = socket_delay
self.messageHandler = MessageHandler(self.mention)
def isPrivate(self, event):
"""Checks if private slack channel"""
return event.get('channel').startswith('D')
def _isForMe(self, event):
eventType = event.get('type')
if not eventType or eventType != 'message' or \
event.get('user') == self.botId:
return False
if self.isPrivate(event):
return 'private'
messageText = event.get('text')
if messageText:
messageText = messageText.lower()
if re.search(str(self.mention), str(messageText)):
return 'mention'
if re.search(str(self.botName), str(messageText)):
return 'name'
def _postMessage(self, messageText, channel):
self.client.api_call('chat.postMessage',
channel=channel,
text=messageText,
as_user=True)
def handle(self, message, user, channel, mention):
privateChannel = channel.startswith('D')
response = self.messageHandler.handle(message, user, mention,
privateChannel)
if response:
return self._postMessage(response, channel)
def run(self):
if not self.client.rtm_connect():
print('[!] Connection to Slack failed.')
return
print('[.] AimBot is ON...')
while True:
eventList = self.client.rtm_read()
if not len(eventList):
continue
for event in eventList:
forMe = self._isForMe(event)
print('forMe: {0}. Event type: {1}'.format(
forMe, event.get('type')))
if not forMe:
continue
mention = bool(forMe == 'mention')
print('mention: {0}'.format(mention))
self.handle(message=event.get('text'),
user=event.get('user'),
channel=event.get('channel'),
mention=mention)
time.sleep(self.delay)
