2016-02-14 00:06:36 +01:00
|
|
|
# -*- coding: utf-8 -*-
|
2016-06-19 19:25:06 +02:00
|
|
|
import time
|
2016-04-04 18:18:42 +02:00
|
|
|
import os
|
2016-03-23 18:35:48 +01:00
|
|
|
import wx
|
2016-02-14 00:06:36 +01:00
|
|
|
import widgetUtils
|
|
|
|
import messages
|
|
|
|
import buffers
|
2016-04-05 00:54:59 +02:00
|
|
|
import configuration
|
2016-02-16 00:49:39 +01:00
|
|
|
import player
|
2016-02-18 00:37:57 +01:00
|
|
|
import posts
|
2018-09-06 17:47:10 +02:00
|
|
|
import profiles
|
2016-04-04 18:18:42 +02:00
|
|
|
import webbrowser
|
2016-05-13 00:44:53 +02:00
|
|
|
import logging
|
2018-12-12 19:24:05 +01:00
|
|
|
import output
|
2018-09-02 15:38:49 +02:00
|
|
|
import longpollthread
|
2016-06-29 05:32:32 +02:00
|
|
|
import selector
|
2018-12-09 12:22:37 +01:00
|
|
|
from vk_api.exceptions import LoginRequired, VkApiError
|
2018-12-12 20:41:57 +01:00
|
|
|
from requests.exceptions import ConnectionError
|
2016-02-14 00:06:36 +01:00
|
|
|
from pubsub import pub
|
|
|
|
from mysc.repeating_timer import RepeatingTimer
|
2016-02-15 23:49:09 +01:00
|
|
|
from mysc.thread_utils import call_threaded
|
2016-06-29 20:16:35 +02:00
|
|
|
from mysc import localization
|
2018-12-13 19:05:48 +01:00
|
|
|
from sessionmanager import session, utils, renderers
|
2016-02-25 12:49:18 +01:00
|
|
|
from wxUI import (mainWindow, commonMessages)
|
2016-03-23 20:52:43 +01:00
|
|
|
from wxUI.dialogs import search as searchDialogs
|
2016-06-19 19:25:06 +02:00
|
|
|
from wxUI.dialogs import timeline, creation
|
2016-02-25 12:49:18 +01:00
|
|
|
from update import updater
|
2016-02-14 00:06:36 +01:00
|
|
|
|
2016-05-13 00:44:53 +02:00
|
|
|
log = logging.getLogger("controller.main")
|
|
|
|
|
2016-02-14 00:06:36 +01:00
|
|
|
class Controller(object):
|
|
|
|
|
|
|
|
def search(self, tab_name):
|
|
|
|
for i in xrange(0, len(self.buffers)):
|
|
|
|
if self.buffers[i].name == tab_name:
|
|
|
|
return self.buffers[i]
|
|
|
|
return False
|
|
|
|
|
2016-02-24 00:49:55 +01:00
|
|
|
def get_current_buffer(self):
|
|
|
|
""" Get the current bufferObject"""
|
|
|
|
buffer = self.window.get_current_buffer()
|
|
|
|
if hasattr(buffer, "name"):
|
|
|
|
buffer = self.search(buffer.name)
|
|
|
|
return buffer
|
|
|
|
|
2016-02-14 00:06:36 +01:00
|
|
|
def __init__(self):
|
|
|
|
super(Controller, self).__init__()
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug("Starting main controller...")
|
2016-02-14 00:06:36 +01:00
|
|
|
self.buffers = []
|
2016-02-16 00:49:39 +01:00
|
|
|
player.setup()
|
2016-02-14 00:06:36 +01:00
|
|
|
self.window = mainWindow.mainWindow()
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug("Main window created")
|
2016-02-14 00:06:36 +01:00
|
|
|
self.window.change_status(_(u"Ready"))
|
|
|
|
self.session = session.sessions[session.sessions.keys()[0]]
|
|
|
|
self.create_controls()
|
|
|
|
self.window.Show()
|
2016-02-23 12:48:05 +01:00
|
|
|
self.connect_events()
|
2016-02-25 12:49:18 +01:00
|
|
|
call_threaded(updater.do_update)
|
2016-02-14 00:06:36 +01:00
|
|
|
|
|
|
|
def create_controls(self):
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug("Creating controls for the window...")
|
2016-03-23 15:57:16 +01:00
|
|
|
posts_ = buffers.empty(parent=self.window.tb, name="posts")
|
|
|
|
self.buffers.append(posts_)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: Name for the posts tab in the tree view.
|
2016-03-23 15:57:16 +01:00
|
|
|
self.window.add_buffer(posts_.tab, _(u"Posts"))
|
2018-12-06 22:37:16 +01:00
|
|
|
home = buffers.baseBuffer(parent=self.window.tb, name="home_timeline", session=self.session, composefunc="render_newsfeed_item", endpoint="newsfeed", count=self.session.settings["buffers"]["count_for_wall_buffers"])
|
2016-02-14 00:06:36 +01:00
|
|
|
self.buffers.append(home)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: Newsfeed's name in the tree view.
|
2016-03-23 15:57:16 +01:00
|
|
|
self.window.insert_buffer(home.tab, _(u"Home"), self.window.search("posts"))
|
2016-02-14 00:06:36 +01:00
|
|
|
self.repeatedUpdate = RepeatingTimer(180, self.update_all_buffers)
|
|
|
|
self.repeatedUpdate.start()
|
2016-06-06 11:27:07 +02:00
|
|
|
self.readMarker = RepeatingTimer(120, self.mark_as_read)
|
|
|
|
self.readMarker.start()
|
2018-12-06 22:37:16 +01:00
|
|
|
feed = buffers.feedBuffer(parent=self.window.tb, name="me_feed", composefunc="render_status", session=self.session, endpoint="get", parent_endpoint="wall", extended=1, count=self.session.settings["buffers"]["count_for_wall_buffers"])
|
2016-02-14 00:06:36 +01:00
|
|
|
self.buffers.append(feed)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: Own user's wall name in the tree view.
|
2016-03-23 15:57:16 +01:00
|
|
|
self.window.insert_buffer(feed.tab, _(u"My wall"), self.window.search("posts"))
|
2017-05-12 10:06:53 +02:00
|
|
|
### Disabled audio stuff for now.
|
2018-12-09 12:22:37 +01:00
|
|
|
audios = buffers.empty(parent=self.window.tb, name="audios")
|
|
|
|
self.buffers.append(audios)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: name for the music category in the tree view.
|
2018-12-09 12:22:37 +01:00
|
|
|
self.window.add_buffer(audios.tab, _(u"Music"))
|
2016-06-19 19:25:06 +02:00
|
|
|
|
2018-12-09 12:22:37 +01:00
|
|
|
audio = buffers.audioBuffer(parent=self.window.tb, name="me_audio", composefunc="render_audio", session=self.session, endpoint="get", parent_endpoint="audio")
|
|
|
|
self.buffers.append(audio)
|
|
|
|
self.window.insert_buffer(audio.tab, _(u"My audios"), self.window.search("audios"))
|
2018-12-06 22:37:16 +01:00
|
|
|
# p_audio = buffers.audioBuffer(parent=self.window.tb, name="popular_audio", composefunc="render_audio", session=self.session, endpoint="getPopular", parent_endpoint="audio", full_list=True, count=self.session.settings["buffers"]["count_for_audio_buffers"])
|
2017-05-12 10:06:53 +02:00
|
|
|
# self.buffers.append(p_audio)
|
|
|
|
# self.window.insert_buffer(p_audio.tab, _(u"Populars"), self.window.search("audios"))
|
2018-12-06 22:37:16 +01:00
|
|
|
# r_audio = buffers.audioBuffer(parent=self.window.tb, name="recommended_audio", composefunc="render_audio", session=self.session, endpoint="getRecommendations", parent_endpoint="audio", full_list=True, count=self.session.settings["buffers"]["count_for_audio_buffers"])
|
2017-05-12 10:06:53 +02:00
|
|
|
# self.buffers.append(r_audio)
|
|
|
|
# self.window.insert_buffer(r_audio.tab, _(u"Recommendations"), self.window.search("audios"))
|
2018-12-09 12:22:37 +01:00
|
|
|
albums = buffers.empty(parent=self.window.tb, name="albums")
|
|
|
|
self.buffers.append(albums)
|
|
|
|
self.window.insert_buffer(albums.tab, _(u"Albums"), self.window.search("audios"))
|
2016-08-14 14:46:41 +02:00
|
|
|
videos = buffers.empty(parent=self.window.tb, name="videos")
|
|
|
|
self.buffers.append(videos)
|
|
|
|
# Translators: name for the videos category in the tree view.
|
|
|
|
self.window.add_buffer(videos.tab, _(u"Video"))
|
2018-12-06 22:37:16 +01:00
|
|
|
my_videos = buffers.videoBuffer(parent=self.window.tb, name="me_video", composefunc="render_video", session=self.session, endpoint="get", parent_endpoint="video", count=self.session.settings["buffers"]["count_for_video_buffers"])
|
2016-08-14 14:46:41 +02:00
|
|
|
self.buffers.append(my_videos)
|
|
|
|
self.window.insert_buffer(my_videos.tab, _(u"My videos"), self.window.search("videos"))
|
|
|
|
video_albums = buffers.empty(parent=self.window.tb, name="video_albums")
|
|
|
|
self.buffers.append(video_albums)
|
|
|
|
self.window.insert_buffer(video_albums.tab, _(u"Albums"), self.window.search("videos"))
|
2016-05-25 18:33:57 +02:00
|
|
|
people = buffers.empty(parent=self.window.tb, name="people")
|
|
|
|
self.buffers.append(people)
|
|
|
|
self.window.add_buffer(people.tab, _(u"People"))
|
2018-12-06 22:37:16 +01:00
|
|
|
friends = buffers.peopleBuffer(parent=self.window.tb, name="friends_", composefunc="render_person", session=self.session, endpoint="get", parent_endpoint="friends", count=5000, fields="uid, first_name, last_name, last_seen")
|
2016-05-25 18:33:57 +02:00
|
|
|
self.buffers.append(friends)
|
|
|
|
self.window.insert_buffer(friends.tab, _(u"Friends"), self.window.search("people"))
|
2016-08-02 17:38:10 +02:00
|
|
|
requests_ = buffers.empty(parent=self.window.tb, name="requests")
|
|
|
|
self.buffers.append(requests_)
|
|
|
|
self.window.insert_buffer(requests_.tab, _(u"Friendship requests"), self.window.search("people"))
|
2018-12-06 22:37:16 +01:00
|
|
|
incoming_requests = buffers.requestsBuffer(parent=self.window.tb, name="friend_requests", composefunc="render_person", session=self.session, count=1000)
|
2016-08-02 17:38:10 +02:00
|
|
|
self.buffers.append(incoming_requests)
|
2018-12-03 22:55:55 +01:00
|
|
|
self.window.insert_buffer(incoming_requests.tab, _(u"Pending requests"), self.window.search("requests"))
|
2018-12-06 22:37:16 +01:00
|
|
|
outgoing_requests = buffers.requestsBuffer(parent=self.window.tb, name="friend_requests_sent", composefunc="render_person", session=self.session, count=1000, out=1)
|
2016-08-02 17:38:10 +02:00
|
|
|
self.buffers.append(outgoing_requests)
|
|
|
|
self.window.insert_buffer(outgoing_requests.tab, _(u"I follow"), self.window.search("requests"))
|
2016-05-17 19:46:57 +02:00
|
|
|
chats = buffers.empty(parent=self.window.tb, name="chats")
|
|
|
|
self.buffers.append(chats)
|
|
|
|
self.window.add_buffer(chats.tab, _(u"Chats"))
|
2016-04-13 20:43:29 +02:00
|
|
|
timelines = buffers.empty(parent=self.window.tb, name="timelines")
|
|
|
|
self.buffers.append(timelines)
|
|
|
|
self.window.add_buffer(timelines.tab, _(u"Timelines"))
|
2016-06-08 12:45:03 +02:00
|
|
|
self.window.realize()
|
2016-02-23 12:48:05 +01:00
|
|
|
|
|
|
|
def connect_events(self):
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug("Connecting events to responses...")
|
2016-02-14 00:06:36 +01:00
|
|
|
pub.subscribe(self.in_post, "posted")
|
2016-02-15 23:49:09 +01:00
|
|
|
pub.subscribe(self.download, "download-file")
|
2018-12-05 22:55:24 +01:00
|
|
|
pub.subscribe(self.play_audio, "play-audio")
|
2018-12-09 12:22:37 +01:00
|
|
|
pub.subscribe(self.play_audios, "play-audios")
|
2016-02-18 00:37:57 +01:00
|
|
|
pub.subscribe(self.view_post, "open-post")
|
2016-03-26 16:08:41 +01:00
|
|
|
pub.subscribe(self.update_status_bar, "update-status-bar")
|
2016-05-25 18:33:57 +02:00
|
|
|
pub.subscribe(self.chat_from_id, "new-chat")
|
2016-06-06 10:53:55 +02:00
|
|
|
pub.subscribe(self.authorisation_failed, "authorisation-failed")
|
2016-09-15 22:27:38 +02:00
|
|
|
pub.subscribe(self.user_profile, "user-profile")
|
2018-12-10 07:48:40 +01:00
|
|
|
pub.subscribe(self.user_online, "user-online")
|
|
|
|
pub.subscribe(self.user_offline, "user-offline")
|
2018-12-11 00:35:36 +01:00
|
|
|
pub.subscribe(self.notify, "notify")
|
2018-12-12 20:41:57 +01:00
|
|
|
pub.subscribe(self.handle_longpoll_read_timeout, "longpoll-read-timeout")
|
2016-02-23 12:48:05 +01:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.CLOSE_EVENT, self.exit)
|
2016-02-24 00:49:55 +01:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.update_buffer, menuitem=self.window.update_buffer)
|
2016-02-25 12:49:18 +01:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.check_for_updates, menuitem=self.window.check_for_updates)
|
2016-03-23 15:38:18 +01:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.window.about_dialog, menuitem=self.window.about)
|
2018-12-09 12:22:37 +01:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.search_audios, menuitem=self.window.search_audios)
|
2016-08-16 00:00:49 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.search_videos, menuitem=self.window.search_videos)
|
2016-03-27 08:11:52 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU,self.remove_buffer, menuitem=self.window.remove_buffer_)
|
2016-03-31 18:33:02 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.get_more_items, menuitem=self.window.load_previous_items)
|
2016-04-04 18:18:42 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.changelog, menuitem=self.window.changelog)
|
2016-04-05 00:54:59 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.configuration, menuitem=self.window.settings_dialog)
|
2016-04-12 22:36:30 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.new_timeline, menuitem=self.window.timeline)
|
2018-12-11 19:07:18 +01:00
|
|
|
# widgetUtils.connect_event(self.window, widgetUtils.MENU, self.create_audio_album, menuitem=self.window.audio_album)
|
2018-12-11 19:08:56 +01:00
|
|
|
# widgetUtils.connect_event(self.window, widgetUtils.MENU, self.delete_audio_album, menuitem=self.window.delete_audio_album)
|
2016-08-14 14:46:41 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.create_video_album, menuitem=self.window.video_album)
|
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.delete_video_album, menuitem=self.window.delete_video_album)
|
2016-06-29 20:16:35 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.check_documentation, menuitem=self.window.documentation)
|
2018-12-09 12:22:37 +01:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.menu_play_pause, menuitem=self.window.player_play)
|
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.menu_play_next, menuitem=self.window.player_next)
|
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.menu_play_previous, menuitem=self.window.player_previous)
|
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.menu_play_all, menuitem=self.window.player_play_all)
|
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.menu_stop, menuitem=self.window.player_stop)
|
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.menu_volume_down, menuitem=self.window.player_volume_down)
|
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.menu_volume_up, menuitem=self.window.player_volume_up)
|
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.menu_mute, menuitem=self.window.player_mute)
|
2016-05-17 19:46:57 +02:00
|
|
|
pub.subscribe(self.get_chat, "order-sent-message")
|
2018-09-06 17:47:10 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.view_my_profile, menuitem=self.window.view_profile)
|
2018-09-06 20:07:55 +02:00
|
|
|
widgetUtils.connect_event(self.window, widgetUtils.MENU, self.view_my_profile_in_browser, menuitem=self.window.open_in_browser)
|
2018-12-09 12:22:37 +01:00
|
|
|
|
2016-02-23 12:48:05 +01:00
|
|
|
def disconnect_events(self):
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug("Disconnecting some events...")
|
2016-02-23 12:48:05 +01:00
|
|
|
pub.unsubscribe(self.in_post, "posted")
|
2018-12-09 12:22:37 +01:00
|
|
|
pub.unsubscribe(self.download, "download-file")
|
|
|
|
pub.unsubscribe(self.play_audio, "play-audio")
|
2016-06-06 10:53:55 +02:00
|
|
|
pub.unsubscribe(self.authorisation_failed, "authorisation-failed")
|
2018-12-09 12:22:37 +01:00
|
|
|
pub.unsubscribe(self.play_audios, "play-audios")
|
2016-02-23 12:48:05 +01:00
|
|
|
pub.unsubscribe(self.view_post, "open-post")
|
2016-03-26 16:08:41 +01:00
|
|
|
pub.unsubscribe(self.update_status_bar, "update-status-bar")
|
2018-12-10 07:48:40 +01:00
|
|
|
pub.unsubscribe(self.user_online, "user-online")
|
|
|
|
pub.unsubscribe(self.user_offline, "user-offline")
|
2018-12-11 00:35:36 +01:00
|
|
|
pub.unsubscribe(self.notify, "notify")
|
2016-02-14 00:06:36 +01:00
|
|
|
|
2016-06-06 10:53:55 +02:00
|
|
|
def authorisation_failed(self):
|
|
|
|
commonMessages.bad_authorisation()
|
|
|
|
|
2016-02-14 00:06:36 +01:00
|
|
|
def login(self):
|
|
|
|
self.window.change_status(_(u"Logging in VK"))
|
2016-02-15 01:46:23 +01:00
|
|
|
self.session.login()
|
2016-02-14 00:06:36 +01:00
|
|
|
self.window.change_status(_(u"Ready"))
|
|
|
|
for i in self.buffers:
|
|
|
|
if hasattr(i, "get_items"):
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: {0} will be replaced with the name of a buffer.
|
2016-02-14 00:06:36 +01:00
|
|
|
self.window.change_status(_(u"Loading items for {0}").format(i.name,))
|
|
|
|
i.get_items()
|
|
|
|
self.window.change_status(_(u"Ready"))
|
2018-12-12 20:41:57 +01:00
|
|
|
self.create_longpoll_thread()
|
2018-12-14 00:16:56 +01:00
|
|
|
self.status_setter = RepeatingTimer(280, self.set_online)
|
2016-06-03 17:24:35 +02:00
|
|
|
self.status_setter.start()
|
|
|
|
self.set_online()
|
|
|
|
self.create_unread_messages()
|
2016-06-19 19:25:06 +02:00
|
|
|
wx.CallAfter(self.get_audio_albums, self.session.user_id)
|
2016-08-14 14:46:41 +02:00
|
|
|
wx.CallAfter(self.get_video_albums, self.session.user_id)
|
2016-06-19 19:25:06 +02:00
|
|
|
|
2018-12-12 20:41:57 +01:00
|
|
|
def create_longpoll_thread(self, notify=False):
|
|
|
|
try:
|
|
|
|
self.longpoll = longpollthread.worker(self.session)
|
|
|
|
self.longpoll.start()
|
|
|
|
if notify:
|
|
|
|
self.notify(message=_(u"Chat server reconnected"))
|
|
|
|
except ConnectionError:
|
|
|
|
pub.sendMessage("longpoll-read-timeout")
|
|
|
|
|
2016-02-14 00:06:36 +01:00
|
|
|
def in_post(self, buffer):
|
|
|
|
buffer = self.search(buffer)
|
|
|
|
buffer.get_items()
|
|
|
|
buffer = self.search("home_timeline")
|
|
|
|
buffer.get_items()
|
|
|
|
|
|
|
|
def update_all_buffers(self):
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug("Updating buffers...")
|
2016-06-29 05:32:32 +02:00
|
|
|
self.session.audio_albums = self.session.vk.client.audio.getAlbums(owner_id=self.session.user_id)["items"]
|
2016-02-14 00:06:36 +01:00
|
|
|
for i in self.buffers:
|
|
|
|
if hasattr(i, "get_items"):
|
|
|
|
i.get_items()
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug(u"Updated %s" % (i.name))
|
2016-02-15 23:49:09 +01:00
|
|
|
|
|
|
|
def download(self, url, filename):
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug(u"downloading %s URL to %s filename" % (url, filename,))
|
2016-02-16 00:49:39 +01:00
|
|
|
call_threaded(utils.download_file, url, filename, self.window)
|
|
|
|
|
|
|
|
def play_audio(self, audio_object):
|
|
|
|
call_threaded(player.player.play, audio_object)
|
2016-02-18 00:37:57 +01:00
|
|
|
|
2016-03-23 15:17:45 +01:00
|
|
|
def play_audios(self, audios):
|
2017-03-13 09:16:34 +01:00
|
|
|
player.player.play_all(audios, shuffle=self.window.player_shuffle.IsChecked())
|
2016-03-23 15:17:45 +01:00
|
|
|
|
2016-02-18 00:37:57 +01:00
|
|
|
def view_post(self, post_object, controller_):
|
|
|
|
p = getattr(posts, controller_)(self.session, post_object)
|
2016-02-23 12:48:05 +01:00
|
|
|
p.dialog.get_response()
|
|
|
|
p.dialog.Destroy()
|
|
|
|
|
|
|
|
def exit(self, *args, **kwargs):
|
2016-05-13 00:44:53 +02:00
|
|
|
log.debug("Receibed an exit signal. closing...")
|
2018-12-10 20:25:30 +01:00
|
|
|
self.set_offline()
|
2016-02-23 12:48:05 +01:00
|
|
|
self.disconnect_events()
|
|
|
|
self.window.Destroy()
|
2016-03-23 20:52:43 +01:00
|
|
|
wx.GetApp().ExitMainLoop()
|
2016-02-24 00:49:55 +01:00
|
|
|
|
|
|
|
def update_buffer(self, *args, **kwargs):
|
|
|
|
b = self.get_current_buffer()
|
2016-02-25 11:52:02 +01:00
|
|
|
b.get_items()
|
2016-02-25 12:49:18 +01:00
|
|
|
|
2016-03-31 18:33:02 +02:00
|
|
|
def get_more_items(self, *args, **kwargs):
|
|
|
|
b = self.get_current_buffer()
|
|
|
|
b.get_more_items()
|
|
|
|
|
2016-02-25 12:49:18 +01:00
|
|
|
def check_for_updates(self, *args, **kwargs):
|
|
|
|
update = updater.do_update()
|
|
|
|
if update == False:
|
|
|
|
commonMessages.no_update_available()
|
2016-03-23 20:52:43 +01:00
|
|
|
|
|
|
|
def search_audios(self, *args, **kwargs):
|
|
|
|
dlg = searchDialogs.searchAudioDialog()
|
|
|
|
if dlg.get_response() == widgetUtils.OK:
|
|
|
|
q = dlg.get("term").encode("utf-8")
|
2018-12-12 01:02:49 +01:00
|
|
|
newbuff = buffers.audioBuffer(parent=self.window.tb, name=u"{0}_audiosearch".format(q.decode("utf-8"),), session=self.session, composefunc="render_audio", parent_endpoint="audio", endpoint="search", q=q)
|
2016-03-23 20:52:43 +01:00
|
|
|
self.buffers.append(newbuff)
|
|
|
|
call_threaded(newbuff.get_items)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: {0} will be replaced with the search term.
|
2016-03-23 20:52:43 +01:00
|
|
|
self.window.insert_buffer(newbuff.tab, _(u"Search for {0}").format(q.decode("utf-8"),), self.window.search("audios"))
|
2016-03-26 16:08:41 +01:00
|
|
|
|
2016-08-16 00:00:49 +02:00
|
|
|
def search_videos(self, *args, **kwargs):
|
|
|
|
dlg = searchDialogs.searchVideoDialog()
|
|
|
|
if dlg.get_response() == widgetUtils.OK:
|
|
|
|
params = {}
|
|
|
|
params["q"] = dlg.get("term").encode("utf-8")
|
|
|
|
params["count"] = 200
|
|
|
|
hd = dlg.get_checkable("hd")
|
|
|
|
if hd != 0:
|
|
|
|
params["hd"] = 1
|
|
|
|
params["adult"] = dlg.get_checkable("safe_search")
|
|
|
|
params["sort"] = dlg.get_sort_order()
|
|
|
|
params["filters"] = "youtube, vimeo, short, long"
|
2018-12-06 22:37:16 +01:00
|
|
|
newbuff = buffers.videoBuffer(parent=self.window.tb, name=u"{0}_videosearch".format(params["q"].decode("utf-8"),), session=self.session, composefunc="render_video", parent_endpoint="video", endpoint="search", **params)
|
2016-08-16 00:00:49 +02:00
|
|
|
self.buffers.append(newbuff)
|
|
|
|
call_threaded(newbuff.get_items)
|
|
|
|
# Translators: {0} will be replaced with the search term.
|
|
|
|
self.window.insert_buffer(newbuff.tab, _(u"Search for {0}").format(params["q"].decode("utf-8"),), self.window.search("videos"))
|
|
|
|
|
2016-03-26 16:08:41 +01:00
|
|
|
def update_status_bar(self, status):
|
2016-03-27 08:11:52 +02:00
|
|
|
self.window.change_status(status)
|
|
|
|
|
2016-04-15 00:23:08 +02:00
|
|
|
def remove_buffer(self, event, mandatory=False, *args, **kwargs):
|
2016-03-27 08:11:52 +02:00
|
|
|
buffer = self.get_current_buffer()
|
|
|
|
buff = self.window.search(buffer.name)
|
2016-04-14 00:45:05 +02:00
|
|
|
answer = buffer.remove_buffer(mandatory)
|
2016-03-27 08:11:52 +02:00
|
|
|
if answer == False:
|
|
|
|
return
|
|
|
|
self.window.remove_buffer(buff)
|
|
|
|
self.buffers.remove(buffer)
|
2016-04-04 18:18:42 +02:00
|
|
|
del buffer
|
|
|
|
|
|
|
|
def changelog(self, *args, **kwargs):
|
|
|
|
os.chdir("documentation")
|
|
|
|
webbrowser.open("changelog.html")
|
|
|
|
os.chdir("../")
|
2016-04-05 00:54:59 +02:00
|
|
|
|
|
|
|
def configuration(self, *args, **kwargs):
|
|
|
|
""" Opens the global settings dialogue."""
|
|
|
|
d = configuration.configuration(self.session)
|
|
|
|
if d.response == widgetUtils.OK:
|
|
|
|
d.save_configuration()
|
2016-04-12 22:36:30 +02:00
|
|
|
|
|
|
|
def new_timeline(self, *args, **kwargs):
|
|
|
|
b = self.get_current_buffer()
|
2016-04-15 16:06:18 +02:00
|
|
|
if not hasattr(b, "get_users"):
|
|
|
|
b = self.search("home_timeline")
|
2016-04-12 22:36:30 +02:00
|
|
|
d = []
|
|
|
|
for i in self.session.db["users"]:
|
2016-07-07 17:20:03 +02:00
|
|
|
d.append((i, self.session.get_user_name(i, "nom")))
|
2016-04-12 22:36:30 +02:00
|
|
|
for i in self.session.db["groups"]:
|
2016-04-19 12:13:58 +02:00
|
|
|
d.append((-i, self.session.get_user_name(-i)))
|
2016-04-12 22:36:30 +02:00
|
|
|
a = timeline.timelineDialog([i[1] for i in d])
|
|
|
|
if a.get_response() == widgetUtils.OK:
|
|
|
|
user = a.get_user()
|
|
|
|
buffertype = a.get_buffer_type()
|
|
|
|
user_id = ""
|
|
|
|
for i in d:
|
|
|
|
if i[1] == user:
|
|
|
|
user_id = i[0]
|
2016-04-12 22:59:22 +02:00
|
|
|
if user_id == None:
|
|
|
|
commonMessages.no_user_exist()
|
|
|
|
return
|
|
|
|
if buffertype == "audio":
|
2018-12-09 12:22:37 +01:00
|
|
|
buffer = buffers.audioBuffer(parent=self.window.tb, name="{0}_audio".format(user_id,), composefunc="render_audio", session=self.session, endpoint="get", parent_endpoint="audio", owner_id=user_id)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: {0} will be replaced with an user.
|
2016-07-07 17:20:03 +02:00
|
|
|
name_ = _(u"{0}'s audios").format(self.session.get_user_name(user_id, "gen"),)
|
2016-04-15 00:23:08 +02:00
|
|
|
elif buffertype == "wall":
|
2018-12-06 22:37:16 +01:00
|
|
|
buffer = buffers.feedBuffer(parent=self.window.tb, name="{0}_feed".format(user_id,), composefunc="render_status", session=self.session, endpoint="get", parent_endpoint="wall", extended=1, count=self.session.settings["buffers"]["count_for_wall_buffers"], owner_id=user_id)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: {0} will be replaced with an user.
|
2016-07-07 17:20:03 +02:00
|
|
|
name_ = _(u"{0}'s wall posts").format(self.session.get_user_name(user_id, "gen"),)
|
2016-06-02 20:12:42 +02:00
|
|
|
elif buffertype == "friends":
|
2018-12-06 22:37:16 +01:00
|
|
|
buffer = buffers.peopleBuffer(parent=self.window.tb, name="friends_{0}".format(user_id,), composefunc="render_person", session=self.session, endpoint="get", parent_endpoint="friends", count=5000, fields="uid, first_name, last_name, last_seen", user_id=user_id)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: {0} will be replaced with an user.
|
2016-07-07 17:20:03 +02:00
|
|
|
name_ = _(u"{0}'s friends").format(self.session.get_user_name(user_id, "friends"),)
|
2016-04-15 00:23:08 +02:00
|
|
|
self.buffers.append(buffer)
|
|
|
|
call_threaded(self.complete_buffer_creation, buffer=buffer, name_=name_, position=self.window.search("timelines"))
|
2016-04-14 00:45:05 +02:00
|
|
|
|
|
|
|
def complete_buffer_creation(self, buffer, name_, position):
|
|
|
|
answer = buffer.get_items()
|
|
|
|
if answer is not True:
|
|
|
|
self.buffers.remove(buffer)
|
|
|
|
del buffer
|
|
|
|
commonMessages.show_error_code(answer)
|
|
|
|
return
|
2016-05-17 19:46:57 +02:00
|
|
|
self.window.insert_buffer(buffer.tab, name_, position)
|
|
|
|
|
|
|
|
def search_chat_buffer(self, user_id):
|
|
|
|
for i in self.buffers:
|
|
|
|
if "_messages" in i.name:
|
|
|
|
if i.kwargs.has_key("user_id") and i.kwargs["user_id"] == user_id: return i
|
|
|
|
return None
|
|
|
|
|
2016-06-03 18:24:14 +02:00
|
|
|
def chat_from_id(self, user_id, setfocus=True):
|
2016-05-25 18:33:57 +02:00
|
|
|
b = self.search_chat_buffer(user_id)
|
|
|
|
if b != None:
|
|
|
|
pos = self.window.search(b.name)
|
2016-06-03 18:24:14 +02:00
|
|
|
if setfocus:
|
|
|
|
self.window.change_buffer(pos)
|
|
|
|
return b.tab.text.SetFocus()
|
|
|
|
return
|
2018-12-06 22:37:16 +01:00
|
|
|
buffer = buffers.chatBuffer(parent=self.window.tb, name="{0}_messages".format(user_id,), composefunc="render_message", session=self.session, count=200, user_id=user_id, rev=0)
|
2016-05-17 19:46:57 +02:00
|
|
|
self.buffers.append(buffer)
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: {0} will be replaced with an user.
|
2016-07-07 21:50:09 +02:00
|
|
|
self.window.insert_buffer(buffer.tab, _(u"Chat with {0}").format(self.session.get_user_name(user_id, "ins")), self.window.search("chats"))
|
2016-06-03 18:24:14 +02:00
|
|
|
if setfocus:
|
|
|
|
pos = self.window.search(buffer.name)
|
|
|
|
self.window.change_buffer(pos)
|
2016-05-25 18:33:57 +02:00
|
|
|
wx.CallAfter(buffer.get_items)
|
2016-06-03 18:24:14 +02:00
|
|
|
if setfocus: buffer.tab.text.SetFocus()
|
2016-05-17 19:46:57 +02:00
|
|
|
return True
|
|
|
|
|
2018-12-10 07:48:40 +01:00
|
|
|
def user_online(self, event):
|
2018-12-11 18:45:38 +01:00
|
|
|
if self.session.settings["chat"]["notify_online"] == False:
|
|
|
|
return
|
2018-12-10 07:48:40 +01:00
|
|
|
user_name = self.session.get_user_name(event.user_id, "nom")
|
|
|
|
msg = _(u"{0} is online.").format(user_name,)
|
2018-12-12 19:24:05 +01:00
|
|
|
sound = "friend_online.ogg"
|
|
|
|
self.notify(msg, sound, self.session.settings["chat"]["notifications"])
|
2018-12-10 07:48:40 +01:00
|
|
|
|
|
|
|
def user_offline(self, event):
|
2018-12-11 18:45:38 +01:00
|
|
|
if self.session.settings["chat"]["notify_offline"] == False:
|
|
|
|
return
|
2018-12-10 07:48:40 +01:00
|
|
|
user_name = self.session.get_user_name(event.user_id, "nom")
|
|
|
|
msg = _(u"{0} is offline.").format(user_name,)
|
2018-12-12 19:24:05 +01:00
|
|
|
sound = "friend_offline.ogg"
|
|
|
|
self.notify(msg, sound, self.session.settings["chat"]["notifications"])
|
2018-12-10 07:48:40 +01:00
|
|
|
|
2016-05-17 19:46:57 +02:00
|
|
|
def get_chat(self, obj=None):
|
|
|
|
""" Searches or creates a chat buffer with the id of the user that is sending or receiving a message.
|
2018-12-09 14:28:13 +01:00
|
|
|
obj vk_api.longpoll.EventType: an event wich defines some data from the vk's long poll server."""
|
2018-12-11 18:45:38 +01:00
|
|
|
# If someone else sends a message to the current user.
|
2018-12-09 14:25:30 +01:00
|
|
|
if obj.to_me:
|
|
|
|
buffer = self.search_chat_buffer(obj.user_id)
|
|
|
|
uid = obj.user_id
|
2018-12-11 18:45:38 +01:00
|
|
|
# If the current user sends a message to someone else.
|
2018-12-09 14:25:30 +01:00
|
|
|
else:
|
|
|
|
buffer = self.search_chat_buffer(obj.peer_id)
|
|
|
|
uid = obj.peer_id
|
2018-12-11 18:45:38 +01:00
|
|
|
# If there is no buffer, we must create one in a wxThread so it will not crash.
|
2016-05-17 19:46:57 +02:00
|
|
|
if buffer == None:
|
2018-12-11 18:45:38 +01:00
|
|
|
wx.CallAfter(self.chat_from_id, uid, setfocus=self.session.settings["chat"]["automove_to_conversations"])
|
2018-12-12 19:38:01 +01:00
|
|
|
self.session.soundplayer.play("conversation_opened.ogg")
|
2016-05-17 19:46:57 +02:00
|
|
|
return
|
|
|
|
# If the chat already exists, let's create a dictionary wich will contains data of the received message.
|
2018-12-09 14:25:30 +01:00
|
|
|
message = {"id": obj.message_id, "user_id": uid, "date": obj.timestamp, "body": obj.text, "attachments": obj.attachments}
|
2017-03-13 09:16:34 +01:00
|
|
|
# if attachments is true, let's request for the full message with attachments formatted in a better way.
|
|
|
|
# Todo: code improvements. We shouldn't need to request the same message again just for these attachments.
|
|
|
|
if len(message["attachments"]) != 0:
|
|
|
|
message_ids = message["id"]
|
|
|
|
results = self.session.vk.client.messages.getById(message_ids=message_ids)
|
|
|
|
message = results["items"][0]
|
2018-12-09 14:25:30 +01:00
|
|
|
if obj.from_me:
|
2016-05-17 19:46:57 +02:00
|
|
|
message["from_id"] = self.session.user_id
|
|
|
|
else:
|
2018-12-09 14:25:30 +01:00
|
|
|
message["from_id"] = obj.user_id
|
2016-05-17 19:46:57 +02:00
|
|
|
data = [message]
|
|
|
|
# Let's add this to the buffer.
|
|
|
|
# ToDo: Clean this code and test how is the database working with this set to True.
|
|
|
|
num = self.session.order_buffer(buffer.name, data, True)
|
|
|
|
buffer.insert(self.session.db[buffer.name]["items"][-1], False)
|
2018-12-11 18:45:38 +01:00
|
|
|
self.session.soundplayer.play("message_received.ogg")
|
2018-12-13 19:05:48 +01:00
|
|
|
# Check if we have to read the message aloud
|
|
|
|
if buffer == self.get_current_buffer():
|
|
|
|
rendered_message = renderers.render_message(message, self.session)
|
|
|
|
output.speak(rendered_message[0])
|
2016-06-03 17:24:35 +02:00
|
|
|
|
|
|
|
def set_online(self):
|
2016-07-12 12:00:07 +02:00
|
|
|
try:
|
|
|
|
r = self.session.vk.client.account.setOnline()
|
|
|
|
except:
|
|
|
|
log.error("Error in setting online for the current user")
|
2018-12-12 12:49:28 +01:00
|
|
|
self.window.notify("Socializer", "online now!")
|
2016-06-03 17:24:35 +02:00
|
|
|
|
2018-12-10 20:25:30 +01:00
|
|
|
def set_offline(self):
|
|
|
|
try:
|
|
|
|
r = self.session.vk.client.account.setOffline()
|
|
|
|
except:
|
|
|
|
log.error("Error in setting offline status for the current user")
|
|
|
|
|
2016-06-03 17:24:35 +02:00
|
|
|
def create_unread_messages(self):
|
2018-12-11 18:45:38 +01:00
|
|
|
if self.session.settings["chat"]["open_unread_conversations"] == False:
|
|
|
|
return
|
2016-08-14 03:12:18 +02:00
|
|
|
try:
|
|
|
|
log.debug("Getting possible unread messages.")
|
|
|
|
msgs = self.session.vk.client.messages.getDialogs(count=200, unread=1)
|
2018-12-09 12:22:37 +01:00
|
|
|
except VkApiError as ex:
|
2016-08-14 03:12:18 +02:00
|
|
|
if ex.code == 6:
|
|
|
|
log.exception("Something went wrong when getting messages. Waiting a second to retry")
|
|
|
|
time.sleep(2)
|
|
|
|
return self.create_unread_messages()
|
2016-06-03 17:24:35 +02:00
|
|
|
for i in msgs["items"]:
|
2016-06-03 18:24:14 +02:00
|
|
|
wx.CallAfter(self.chat_from_id, i["message"]["user_id"], setfocus=False)
|
2016-06-06 11:27:07 +02:00
|
|
|
|
|
|
|
def mark_as_read(self):
|
|
|
|
ids = ""
|
|
|
|
for i in self.buffers:
|
|
|
|
if hasattr(i, "reads"):
|
|
|
|
for z in i.reads:
|
|
|
|
ids = ids+"%d," % (z,)
|
|
|
|
i.reads = []
|
|
|
|
if ids != "":
|
|
|
|
response = self.session.vk.client.messages.markAsRead(message_ids=ids)
|
2016-06-19 19:25:06 +02:00
|
|
|
|
|
|
|
def get_audio_albums(self, user_id=None):
|
2016-08-14 03:12:18 +02:00
|
|
|
try:
|
|
|
|
log.debug("Create audio albums...")
|
2018-12-11 18:45:38 +01:00
|
|
|
albums = self.session.vk.client_audio.get_albums(owner_id=user_id)
|
2018-12-09 12:22:37 +01:00
|
|
|
except VkApiError as ex:
|
2016-08-14 03:12:18 +02:00
|
|
|
if ex.code == 6:
|
|
|
|
log.exception("Something went wrong when getting albums. Waiting a second to retry")
|
|
|
|
time.sleep(2)
|
|
|
|
return self.get_audio_albums(user_id=user_id)
|
2016-09-15 22:27:38 +02:00
|
|
|
elif ex.code == 10:
|
|
|
|
return
|
2018-12-11 18:45:38 +01:00
|
|
|
self.session.audio_albums = albums
|
|
|
|
for i in albums:
|
2018-12-11 19:04:04 +01:00
|
|
|
buffer = buffers.audioAlbum(parent=self.window.tb, name="{0}_audio_album".format(i["id"],), composefunc="render_audio", session=self.session, endpoint="get", parent_endpoint="audio", owner_id=user_id, album_id=i["id"])
|
2016-06-29 19:33:09 +02:00
|
|
|
buffer.can_get_items = False
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: {0} Will be replaced with an audio album's title.
|
2016-06-19 19:25:06 +02:00
|
|
|
name_ = _(u"Album: {0}").format(i["title"],)
|
|
|
|
self.buffers.append(buffer)
|
|
|
|
self.window.insert_buffer(buffer.tab, name_, self.window.search("albums"))
|
|
|
|
buffer.get_items()
|
|
|
|
# inserts a pause of 1 second here, so we'll avoid errors 6 in VK.
|
2016-08-11 00:37:36 +02:00
|
|
|
time.sleep(0.3)
|
2016-06-19 19:25:06 +02:00
|
|
|
|
2016-08-14 14:46:41 +02:00
|
|
|
def get_video_albums(self, user_id=None):
|
|
|
|
try:
|
|
|
|
log.debug("Create video albums...")
|
|
|
|
albums = self.session.vk.client.video.getAlbums(owner_id=user_id)
|
2018-12-09 12:22:37 +01:00
|
|
|
except VkApiError as ex:
|
2016-08-14 14:46:41 +02:00
|
|
|
if ex.code == 6:
|
|
|
|
log.exception("Something went wrong when getting albums. Waiting a second to retry")
|
|
|
|
time.sleep(2)
|
|
|
|
return self.get_audio_albums(user_id=user_id)
|
|
|
|
self.session.video_albums = albums["items"]
|
|
|
|
for i in albums["items"]:
|
2018-12-06 22:37:16 +01:00
|
|
|
buffer = buffers.videoAlbum(parent=self.window.tb, name="{0}_video_album".format(i["id"],), composefunc="render_video", session=self.session, endpoint="get", parent_endpoint="video", count=self.session.settings["buffers"]["count_for_video_buffers"], user_id=user_id, album_id=i["id"])
|
2016-08-14 14:46:41 +02:00
|
|
|
buffer.can_get_items = False
|
|
|
|
# Translators: {0} Will be replaced with a video album's title.
|
|
|
|
name_ = _(u"Album: {0}").format(i["title"],)
|
|
|
|
self.buffers.append(buffer)
|
|
|
|
self.window.insert_buffer(buffer.tab, name_, self.window.search("video_albums"))
|
|
|
|
buffer.get_items()
|
|
|
|
# inserts a pause of 1 second here, so we'll avoid errors 6 in VK.
|
|
|
|
time.sleep(0.3)
|
|
|
|
|
2016-06-19 19:25:06 +02:00
|
|
|
def create_audio_album(self, *args, **kwargs):
|
|
|
|
d = creation.audio_album()
|
|
|
|
if d.get_response() == widgetUtils.OK and d.get("title") != "":
|
|
|
|
response = self.session.vk.client.audio.addAlbum(title=d.get("title"))
|
|
|
|
if response.has_key("album_id") == False: return
|
|
|
|
album_id = response["album_id"]
|
2018-12-06 22:37:16 +01:00
|
|
|
buffer = buffers.audioAlbum(parent=self.window.tb, name="{0}_audio_album".format(album_id,), composefunc="render_audio", session=self.session, endpoint="get", parent_endpoint="audio", full_list=True, count=self.session.settings["buffers"]["count_for_audio_buffers"], user_id=self.session.user_id, album_id=album_id)
|
2016-06-29 19:33:09 +02:00
|
|
|
buffer.can_get_items = False
|
2016-06-29 17:56:41 +02:00
|
|
|
# Translators: {0} will be replaced with an audio album's title.
|
2016-06-19 19:25:06 +02:00
|
|
|
name_ = _(u"Album: {0}").format(d.get("title"),)
|
|
|
|
self.buffers.append(buffer)
|
|
|
|
self.window.insert_buffer(buffer.tab, name_, self.window.search("albums"))
|
2016-06-29 05:32:32 +02:00
|
|
|
buffer.get_items()
|
|
|
|
self.session.audio_albums = self.session.vk.client.audio.getAlbums(owner_id=self.session.user_id)["items"]
|
|
|
|
|
|
|
|
def delete_audio_album(self, *args, **kwargs):
|
2016-08-14 14:46:41 +02:00
|
|
|
answer = selector.album(_(u"Select the album you want to delete"), self.session)
|
2016-06-29 05:32:32 +02:00
|
|
|
if answer.item == None:
|
|
|
|
return
|
|
|
|
response = commonMessages.delete_audio_album()
|
|
|
|
if response != widgetUtils.YES: return
|
|
|
|
removal = self.session.vk.client.audio.deleteAlbum(album_id=answer.item)
|
|
|
|
buffer = self.search("{0}_audio_album".format(answer.item,))
|
|
|
|
buff = self.window.search(buffer.name)
|
|
|
|
self.window.remove_buffer(buff)
|
|
|
|
self.buffers.remove(buffer)
|
|
|
|
del buffer
|
|
|
|
self.session.audio_albums = self.session.vk.client.audio.getAlbums(owner_id=self.session.user_id)["items"]
|
2016-06-29 20:16:35 +02:00
|
|
|
|
2016-08-14 14:46:41 +02:00
|
|
|
def create_video_album(self, *args, **kwargs):
|
|
|
|
d = creation.audio_album()
|
|
|
|
if d.get_response() == widgetUtils.OK and d.get("title") != "":
|
|
|
|
response = self.session.vk.client.video.addAlbum(title=d.get("title"))
|
|
|
|
if response.has_key("album_id") == False: return
|
|
|
|
album_id = response["album_id"]
|
2018-12-06 22:37:16 +01:00
|
|
|
buffer = buffers.videoAlbum(parent=self.window.tb, name="{0}_video_album".format(album_id,), composefunc="render_video", session=self.session, endpoint="get", parent_endpoint="video", count=self.session.settings["buffers"]["count_for_video_buffers"], user_id=self.session.user_id, album_id=album_id)
|
2016-08-14 14:46:41 +02:00
|
|
|
buffer.can_get_items = False
|
|
|
|
# Translators: {0} will be replaced with a video album's title.
|
|
|
|
name_ = _(u"Album: {0}").format(d.get("title"),)
|
|
|
|
self.buffers.append(buffer)
|
|
|
|
self.window.insert_buffer(buffer.tab, name_, self.window.search("video_albums"))
|
|
|
|
buffer.get_items()
|
|
|
|
self.session.video_albums = self.session.vk.client.video.getAlbums(owner_id=self.session.user_id)["items"]
|
|
|
|
|
|
|
|
def delete_video_album(self, *args, **kwargs):
|
|
|
|
answer = selector.album(_(u"Select the album you want to delete"), self.session, "video_albums")
|
|
|
|
if answer.item == None:
|
|
|
|
return
|
|
|
|
response = commonMessages.delete_audio_album()
|
|
|
|
if response != widgetUtils.YES: return
|
|
|
|
removal = self.session.vk.client.video.deleteAlbum(album_id=answer.item)
|
|
|
|
buffer = self.search("{0}_video_album".format(answer.item,))
|
|
|
|
buff = self.window.search(buffer.name)
|
|
|
|
self.window.remove_buffer(buff)
|
|
|
|
self.buffers.remove(buffer)
|
|
|
|
del buffer
|
|
|
|
self.session.video_albums = self.session.vk.client.video.getAlbums(owner_id=self.session.user_id)["items"]
|
|
|
|
|
2016-06-29 20:16:35 +02:00
|
|
|
def check_documentation(self, *args, **kwargs):
|
|
|
|
lang = localization.get("documentation")
|
|
|
|
os.chdir("documentation/%s" % (lang,))
|
|
|
|
webbrowser.open("manual.html")
|
|
|
|
os.chdir("../../")
|
2016-07-19 00:34:37 +02:00
|
|
|
|
|
|
|
def menu_play_pause(self, *args, **kwargs):
|
|
|
|
if player.player.check_is_playing() != False:
|
|
|
|
return player.player.pause()
|
|
|
|
b = self.get_current_buffer()
|
2016-09-15 22:27:38 +02:00
|
|
|
if hasattr(b, "play_next"):
|
2016-07-19 00:34:37 +02:00
|
|
|
b.play_audio()
|
|
|
|
else:
|
|
|
|
b = self.search("me_audio")
|
|
|
|
b.play_audio()
|
|
|
|
|
|
|
|
def menu_play_next(self, *args, **kwargs):
|
|
|
|
b = self.get_current_buffer()
|
|
|
|
if hasattr(b, "play_next"):
|
|
|
|
b.play_next()
|
|
|
|
else:
|
|
|
|
self.search("me_audio").play_next()
|
|
|
|
|
|
|
|
def menu_play_previous(self, *args, **kwargs):
|
|
|
|
b = self.get_current_buffer()
|
|
|
|
if hasattr(b, "play_previous"):
|
|
|
|
b.play_previous()
|
|
|
|
else:
|
|
|
|
self.search("me_audio").play_previous()
|
|
|
|
|
|
|
|
def menu_play_all(self, *args, **kwargs):
|
|
|
|
b = self.get_current_buffer()
|
|
|
|
if hasattr(b, "play_all"):
|
|
|
|
b.play_all()
|
|
|
|
else:
|
|
|
|
self.search("me_audio").play_all()
|
|
|
|
|
|
|
|
def menu_stop(self, *args, **kwargs):
|
|
|
|
player.player.stop()
|
|
|
|
|
|
|
|
def menu_volume_down(self, *args, **kwargs):
|
|
|
|
player.player.volume = player.player.volume-5
|
|
|
|
|
|
|
|
def menu_volume_up(self, *args, **kwargs):
|
|
|
|
player.player.volume = player.player.volume+5
|
|
|
|
|
|
|
|
def menu_mute(self, *args, **kwargs):
|
|
|
|
player.player.volume = 0
|
|
|
|
|
2016-09-15 22:27:38 +02:00
|
|
|
def user_profile(self, person):
|
2018-09-06 17:47:10 +02:00
|
|
|
p = profiles.userProfile(self.session, person)
|
|
|
|
|
|
|
|
def view_my_profile(self, *args, **kwargs):
|
2018-09-06 20:07:55 +02:00
|
|
|
self.user_profile(self.session.user_id)
|
|
|
|
|
|
|
|
def view_my_profile_in_browser(self, *args, **kwargs):
|
2018-12-11 00:35:36 +01:00
|
|
|
webbrowser.open_new_tab("https://vk.com/id{id}".format(id=self.session.user_id,))
|
|
|
|
|
2018-12-12 19:24:05 +01:00
|
|
|
def notify(self, message="", sound="", type="native"):
|
|
|
|
if type == "native":
|
|
|
|
self.window.notify(_("Socializer"), message)
|
|
|
|
else:
|
|
|
|
if sound != "":
|
|
|
|
self.session.soundplayer.play(sound)
|
|
|
|
if message != "":
|
2018-12-12 20:41:57 +01:00
|
|
|
output.speak(message)
|
|
|
|
|
|
|
|
def handle_longpoll_read_timeout(self):
|
|
|
|
if hasattr(self, "longpoll"):
|
|
|
|
self.notify(message=_(u"Chat disconnected. Trying to connect in 60 seconds"))
|
|
|
|
time.sleep(60)
|
|
|
|
if hasattr(self, "longpoll"):
|
|
|
|
del self.longpoll
|
|
|
|
self.create_longpoll_thread(notify=True)
|