def __init__(self, filename, x_pos_percent=0, y_pos_percent=0):
"""Initialize the Texture object"""
Base.__init__(self)
clutter.Texture.__init__(self, filename)
self.logger = Logger().getLogger('gui.widgets.Texture')
self._position = None
self._set_position((x_pos_percent, y_pos_percent))
def __init__(self):
"""Create a new music database object."""
self.logger = Logger().getLogger(
'backend.components.mediacache.MusicCache')
self.config = Configuration()
if not os.path.exists(self.config.MUSIC_DB):
self.__createMusicCacheDatabase()
self.__db_conn = sqlite.connect(self.config.MUSIC_DB)
self.__db_cursor = self.__db_conn.cursor()
def __init__(self, socket, message_bus):
"""
Create a new client connection
@param socket: Socket object
@param message_bus: MessageBus object
"""
threading.Thread.__init__(self)
MessageHandler.__init__(self)
self.message_bus = message_bus
self.logger = Logger().getLogger('backend.core.ClientConnection')
self.client_out = socket
self.client = socket.makefile()
self.client_name = "Unknown" # Client name
self.message_bus_connected = False # Is connected to the message bus
def __init__(self):
"""
Create a new MediaCacheManager object
"""
MessageHandler.__init__(self)
self.logger = Logger().getLogger(
'backend.components.mediacache.MediaCacheManager')
self.config = Configuration()
self.video_folders = self.config.media_folders
self._index_videos(self.video_folders)
self.music_folders = self.config.media_folders
self._index_music(self.music_folders)
self.image_folders = self.config.media_folders
self._index_images(self.image_folders)
def __init__(self):
"""
Create a new MessageBus object.
"""
# MessageHandlers - index is MessageType and data is a list of
# tuples (priority, MessageHandler object) that is sorted by
# priorities.
#XXX: rockstar - WTF?! Why is there a list comprehension being used
# and still only returning an empty list?
# pylint: disable-msg=W0612
self.message_handlers = [
[] for i in range(self.NUMBER_OF_MESSAGE_TYPES)
]
self.lock = threading.Lock()
self.logger = Logger().getLogger('backend.core.MessageBus')
def __init__(self):
"""
Create a new ImageCache.
Creates a new database if not already exists and opens a connection
to it.
"""
self.logger = Logger().getLogger(
'backend.components.mediacache.ImageCache')
self.config = Configuration()
if not os.path.exists(self.config.IMAGE_DB):
self._createImageCacheDatabase()
self.db_conn = sqlite.connect(self.config.IMAGE_DB)
self.db_cursor = self.db_conn.cursor()
def __init__(self, filename):
"""
Initialize metadata search thread.
@param filename: Filename as string (find metadata for this file)
"""
threading.Thread.__init__(self)
self.setName("Video metadata search thread")
self.logger = Logger().getLogger(
'backend.components.mediacache.VideoMetadataSearch')
self.config = Configuration()
self.filename = filename
self.title, self.season, self.episode = self._parse_filename(filename)
try:
self.IMDb = imdb.IMDb()
except imdb.IMDbError:
raise IOError("Couldn't connect to IMDB server!")
def __init__(self, port, message_bus):
"""
Creates a new ConnectionServer object
@param port: Port number for this server
@param message_bus: Bind connecting client to this MessageBus object
"""
threading.Thread.__init__(self)
self.message_bus = message_bus # Message bus
self.logger = Logger().getLogger('backend.core.ConnectionServer')
# Is ConnectionServer active (listening incoming connections)
self.active = False
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self.server_socket.bind(('localhost', port))
except socket.error, e:
message = e[1]
self.logger.error("Socket failed to bind. %s" % message)
# socket binding is critical to the backend, so exit
sys.exit(1)
def __init__(self, stage, width, height):
gobject.GObject.__init__(self)
self._motion_buffer = MotionBuffer()
self._event_mode = self.MODE_NONE
self._motion_handler = 0
self.stage = stage # Stage that displays textures
# Stage background color when not playing
self.bgcolor = stage.get_color()
self.stage_width = width # Stage width used for video resizing
self.stage_height = height # Stage height used for video resizing
self.ratio = MediaPlayer.NATIVE # Video texture ratio
self.audio_skip_step = 10 # Audio skip step in seconds
self.video_skip_step = 60 # Video skip step in seconds
self.playlist = None # Current play list
self.media = None # Current media (Playable object)
self.shuffle = False # Shuffle mode
self.repeat = False # Repeat mode
self.is_playing = False # Is media player currently playing
self.is_reactive_allowed = False # Is the video_texture reactive
self.logger = Logger().getLogger('client.MediaPlayer')
self._internal_callback_timeout_key = None
self.video_texture = cluttergst.VideoTexture()
self.pipeline = self.video_texture.get_pipeline()
self.pipeline.set_property("volume", 0.5)
self._volume = 10
self.bus = self.pipeline.get_bus()
self.bus.add_signal_watch()
self.bus.connect('message', self._on_gst_message)
self.video_texture.set_reactive(True)
self.video_texture.connect('size-change', self._on_size_change)
self.video_texture.connect('scroll-event', self._on_scroll_event)
self.video_texture.connect('button-press-event',
self._on_button_press_event)
self.video_texture.connect('button-release-event',
self._on_button_release_event)
def __init__(self):
gobject.threads_init()
self.config = Configuration()
self.logger = Logger().getLogger('backend.BackendServer')
self.message_bus = MessageBus()
self._port = self.config.port
# Connection server - Thread that listens incoming socket connections
self.connection_server = None
self.scheduler = None
self.media_manager = None
# The order of the initialize method calls is significant! Don't change
# the order unless you know what you are doing!
self.initialize_configuration()
self.initialize_media_cache_manager()
self.initialize_connection_server()
self.initialize_scheduler()
def __init__(self, image_library, music_library, video_library,
quit_client_callback):
self.quit_client_callback = quit_client_callback
self.config = Configuration()
# Store the dimensions in case users want to return to window mode
self.old_width = self.config.stage_width
self.old_height = self.config.stage_height
self.logger = Logger().getLogger('client.gui.UserInterface')
self.window = gtk.Window()
self.window.connect('destroy', self.destroy_callback)
self.window.set_title('Entertainer')
# Set the window icon
icon_theme = gtk.icon_theme_get_default()
try:
icon = icon_theme.load_icon('entertainer', 48, 0)
self.window.set_icon(icon)
except gobject.GError:
# Must not be installed from a package, get icon from the branch
file_dir = os.path.dirname(__file__)
icon_path = os.path.join(file_dir, '..', '..', 'icons',
'hicolor', '48x48', 'apps', 'entertainer.png')
icon = gtk.gdk.pixbuf_new_from_file(icon_path)
self.window.set_icon(icon)
# cluttergtk.Embed contains the stage that is the canvas for the GUI
embed = cluttergtk.Embed()
# Enforce a minimum size to prevent weird widget bugs
embed.set_size_request(
self.config.stage_width, self.config.stage_height)
self.window.add(embed)
# The embed widget must be realized before you can get the stage.
embed.realize()
self.stage = embed.get_stage()
self._hide_cursor_timeout_key = None
self.stage.connect('key-press-event', self.handle_keyboard_event)
self.stage.connect('motion-event', self._handle_motion_event)
self.stage.set_color(self.config.theme.get_color("background"))
self.stage.set_size(self.config.stage_width, self.config.stage_height)
self.stage.set_title("Entertainer")
if self.config.start_in_fullscreen:
self._fullscreen()
self.is_fullscreen = True
else:
self.is_fullscreen = False
# Initialize Screen history (allows user to navigate "back")
self.history = ScreenHistory(self._remove_from_stage)
self.player = MediaPlayer(self.stage,
self.config.stage_width, self.config.stage_height)
self.player.connect('volume-changed', self._on_volume_changed)
# Initialize menu overlay texture
self.is_overlay = False
self.menu_overlay = MenuOverlay(self.config.theme)
self.menu_overlay.set_opacity(0)
self.menu_overlay.set_size(
self.config.stage_width, self.config.stage_height)
self.stage.add(self.menu_overlay)
self.volume_indicator = VolumeIndicator()
self.stage.add(self.volume_indicator)
self.volume_indicator.connect('hiding',
self._on_volume_indicator_hiding)
self.fade_screen_timeline = clutter.Timeline(200)
alpha = clutter.Alpha(self.fade_screen_timeline,
clutter.EASE_IN_OUT_SINE)
self.fade_screen_behaviour = clutter.BehaviourOpacity(255, 0, alpha)
# Transition object. Handles effects between screen changes.
transition_factory = TransitionFactory(self._remove_from_stage)
self.transition = transition_factory.generate_transition()
# Screen factory to create new screens
self.screen_factory = ScreenFactory(
image_library, music_library, video_library, self.player,
self.move_to_new_screen, self.move_to_previous_screen)
def default_key_to_user_event():
'''Return the default user event provided by an unmapped keyboard
event.'''
return UserEvent.DEFAULT_EVENT
# Dictionary for keyboard event handling
self.key_to_user_event = defaultdict(default_key_to_user_event, {
clutter.keysyms.Return : UserEvent.NAVIGATE_SELECT,
clutter.keysyms.Up : UserEvent.NAVIGATE_UP,
clutter.keysyms.Down : UserEvent.NAVIGATE_DOWN,
clutter.keysyms.Left : UserEvent.NAVIGATE_LEFT,
clutter.keysyms.Right : UserEvent.NAVIGATE_RIGHT,
clutter.keysyms.BackSpace : UserEvent.NAVIGATE_BACK,
clutter.keysyms.h : UserEvent.NAVIGATE_HOME,
clutter.keysyms.w : UserEvent.NAVIGATE_FIRST_PAGE,
clutter.keysyms.e : UserEvent.NAVIGATE_PREVIOUS_PAGE,
clutter.keysyms.r : UserEvent.NAVIGATE_NEXT_PAGE,
clutter.keysyms.t : UserEvent.NAVIGATE_LAST_PAGE,
clutter.keysyms.f : UserEvent.TOGGLE_FULLSCREEN,
clutter.keysyms.p : UserEvent.PLAYER_PLAY_PAUSE,
clutter.keysyms.s : UserEvent.PLAYER_STOP,
clutter.keysyms._1 : UserEvent.USE_ASPECT_RATIO_1,
clutter.keysyms._2 : UserEvent.USE_ASPECT_RATIO_2,
clutter.keysyms._3 : UserEvent.USE_ASPECT_RATIO_3,
clutter.keysyms._4 : UserEvent.USE_ASPECT_RATIO_4,
clutter.keysyms.x : UserEvent.PLAYER_SKIP_BACKWARD,
clutter.keysyms.c : UserEvent.PLAYER_SKIP_FORWARD,
clutter.keysyms.z : UserEvent.PLAYER_PREVIOUS,
clutter.keysyms.v : UserEvent.PLAYER_NEXT,
clutter.keysyms.m : UserEvent.PLAYER_VOLUME_UP,
clutter.keysyms.l : UserEvent.PLAYER_VOLUME_DOWN,
clutter.keysyms.q : UserEvent.QUIT,
clutter.keysyms.Escape : UserEvent.QUIT
})
self.event_handlers = {
UserEvent.DEFAULT_EVENT : self._handle_default,
UserEvent.NAVIGATE_SELECT : self._handle_default,
UserEvent.NAVIGATE_UP : self._handle_default,
UserEvent.NAVIGATE_DOWN : self._handle_default,
UserEvent.NAVIGATE_LEFT : self._handle_default,
UserEvent.NAVIGATE_RIGHT : self._handle_default,
UserEvent.NAVIGATE_BACK : self._handle_navigate_back,
UserEvent.NAVIGATE_HOME : self._handle_navigate_home,
UserEvent.NAVIGATE_FIRST_PAGE : self._handle_default,
UserEvent.NAVIGATE_PREVIOUS_PAGE : self._handle_default,
UserEvent.NAVIGATE_NEXT_PAGE : self._handle_default,
UserEvent.NAVIGATE_LAST_PAGE : self._handle_default,
UserEvent.TOGGLE_FULLSCREEN : self._handle_toggle_fullscreen,
UserEvent.PLAYER_PLAY_PAUSE : self._handle_player_play_pause,
UserEvent.PLAYER_STOP : self._handle_player_stop,
UserEvent.USE_ASPECT_RATIO_1 : self._handle_aspect_ratio,
UserEvent.USE_ASPECT_RATIO_2 : self._handle_aspect_ratio,
UserEvent.USE_ASPECT_RATIO_3 : self._handle_aspect_ratio,
UserEvent.USE_ASPECT_RATIO_4 : self._handle_aspect_ratio,
UserEvent.PLAYER_SKIP_BACKWARD : self._handle_player_skip_backward,
UserEvent.PLAYER_SKIP_FORWARD : self._handle_player_skip_forward,
UserEvent.PLAYER_PREVIOUS : self._handle_player_previous,
UserEvent.PLAYER_NEXT : self._handle_player_next,
UserEvent.PLAYER_VOLUME_UP : self._handle_player_volume_up,
UserEvent.PLAYER_VOLUME_DOWN : self._handle_player_volume_down,
UserEvent.QUIT : self._handle_quit_client
}
self.logger.debug("Frontend GUI initialized succesfully")
def __init__(self):
self.configuration = Configuration()
self.logger = Logger().getLogger(
'entertainerlib.indexer.indexing.Indexer')
def setUp(self):
'''See unittest.TestCase'''
EntertainerTest.setUp(self)
self.logger = Logger()
def __init__(self, stand_alone):
self.logfile_entertainer = Configuration().LOG
self.logger = Logger().getLogger('utils.log_viewer')
self.__STAND_ALONE = stand_alone
try:
uifile = os.path.join(self.UI_DIR, "log_dialog.ui")
self.builder = gtk.Builder()
self.builder.set_translation_domain('entertainer')
self.builder.add_from_file(uifile)
except RuntimeError:
self.logger.critical("Couldn't open ui file: " + uifile)
sys.exit(1)
callback_dic = {
"on_close_log_button_clicked" : self.on_close_log_button_clicked,
"on_log_refresh_button_clicked" : self.update_log_rows,
"on_checkbutton_debug_toggled" : self.filter_messages,
"on_checkbutton_critical_toggled" : self.filter_messages,
"on_checkbutton_error_toggled" : self.filter_messages,
"on_checkbutton_warning_toggled" : self.filter_messages,
"on_checkbutton_info_toggled" : self.filter_messages }
self.builder.connect_signals(callback_dic)
# Create log treeview
treeview = self.builder.get_object("treeview_log")
cell_renderer1 = gtk.CellRendererText()
cell_renderer2 = gtk.CellRendererText()
cell_renderer3 = gtk.CellRendererText()
cell_renderer4 = gtk.CellRendererText()
column1 = gtk.TreeViewColumn("Date")
column1.pack_start(cell_renderer1, True)
column1.set_attributes(cell_renderer1, text = 0)
column2 = gtk.TreeViewColumn("Time")
column2.pack_start(cell_renderer2, True)
column2.set_attributes(cell_renderer2, text = 1)
column3 = gtk.TreeViewColumn("Type")
column3.pack_start(cell_renderer3, True)
column3.set_attributes(cell_renderer3, text = 2)
column4 = gtk.TreeViewColumn("Message")
column4.pack_end(cell_renderer4, True)
column4.set_attributes(cell_renderer4, text = 3)
treeview.append_column(column1)
treeview.append_column(column2)
treeview.append_column(column3)
treeview.append_column(column4)
treeview.set_headers_visible(True)
# Set model to view and read data from logfile
self.log_store = gtk.ListStore(str, str, str, str)
treeview.set_model(self.log_store)
self.update_log_rows()
# Show Log viewer dialog
self.dialog = self.builder.get_object("LogDialog")
self.dialog.resize(750, 500)
self.dialog.connect("destroy", self.on_close_log_button_clicked)
self.dialog.show()
