#!/usr/bin/env python


import gobject
gobject.threads_init()

import pygst
pygst.require("0.10")

import gst

import sys, os
import pygtk, gtk


class GTK_Main:

    def __init__(self):
        window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        window.set_title("Video Conference Test Runs")
        window.set_default_size(800, 600)
        window.connect("destroy", gtk.main_quit, "WM destroy")

        self.users = gtk.ListStore (str)
        self.users.append (['User1'])
        self.users.append (['User2'])

        # horizontal container
        hbox = gtk.HBox()
        window.add(hbox)

        # the vertical container to the left which will hold our view and the treeview
        vbox = gtk.VBox()
        hbox.pack_start(vbox, False, padding=5)

        # Add our tree view
        self.list_users = gtk.TreeView(self.users)
        self.list_users.set_size_request (150, 300)

        cell = gtk.CellRendererText()

        col = gtk.TreeViewColumn ("Online Users:")
        col.pack_start (cell, True)
        col.set_attributes(cell, text=0)

        self.list_users.append_column (col)

        vbox.pack_start (self.list_users, padding=5)

        # Our viewing area, the region where we will see ourselves
        self.my_view = gtk.DrawingArea ()
        vbox.add (self.my_view)

        # The large viewing area where we will see the other party
        self.remote_view = gtk.DrawingArea()
        hbox.add(self.remote_view)

        self._setupPipelines()
        window.show_all()

        self.localview.set_state (gst.STATE_PLAYING)
        self.remoteview.set_state (gst.STATE_PLAYING)

    def _setupPipelines (self):
        # a simple video test src pipelines for both views
        #

        self._setupLocalPipeline ()
        self._setupRemotePipeline ()

    def _setupLocalPipeline(self):
        # local pipeline, view our camera locally
        self.localview = gst.Pipeline ('localview0')

        # videotestsrc -> ffmpegcolorspace -> video
        src = gst.element_factory_make ("v4l2src", "videotestsrc0")
        colorspace = gst.element_factory_make ("ffmpegcolorspace", "colorspace0")
        videoout = gst.element_factory_make ("autovideosink", "autovideosink0")

        self.localview.add (src, colorspace, videoout)
        gst.element_link_many (src, colorspace, videoout)

        bus = self.localview.get_bus ()
        bus.add_signal_watch ()
        bus.enable_sync_message_emission ()
        bus.connect ("message", self.on_localview_message)
        bus.connect ("sync-message::element", self.on_localview_sync_message)

    def _setupRemotePipeline(self):
        # remote pipeline, view our camera locally
        self.remoteview = gst.Pipeline ('remoteview0')

        # videotestsrc -> ffmpegcolorspace -> video
        src = gst.element_factory_make ("videotestsrc", "videotestsrc_rem0")
        colorspace = gst.element_factory_make ("ffmpegcolorspace", "colorspace_rem0")
        videoout = gst.element_factory_make ("autovideosink", "autovideosink_rem0")

        self.remoteview.add (src, colorspace, videoout)
        gst.element_link_many (src, colorspace, videoout)

        bus = self.remoteview.get_bus ()
        bus.add_signal_watch ()
        bus.enable_sync_message_emission ()
        bus.connect ("message", self.on_remoteview_message)
        bus.connect ("sync-message::element", self.on_remoteview_sync_message)

    def on_localview_message(self, bus, message):
        if message.type == gst.MESSAGE_ERROR:
            err, debug = message.parse_error ()
            print err, debug

    def on_localview_sync_message (self, bus, message):
        if message.structure is None:
            return

        mn = message.structure.get_name()
        if mn == "prepare-xwindow-id":
            imagesink = message.src
            imagesink.set_property("force-aspect-ratio", True)
            imagesink.set_xwindow_id (self.my_view.window.xid)

    def on_remoteview_message(self, bus, message):
        if message.type == gst.MESSAGE_ERROR:
            err, debug = message.parse_error ()
            print err, debug

    def on_remoteview_sync_message (self, bus, message):
        if message.structure is None:
            return

        mn = message.structure.get_name()
        if mn == "prepare-xwindow-id":
            imagesink = message.src
            imagesink.set_property("force-aspect-ratio", True)
            imagesink.set_xwindow_id (self.remote_view.window.xid)




GTK_Main()
gtk.gdk.threads_init()
gtk.main()