from PyOSG import *
from OpenGL.GL import *
import os

# class to handle events with a pick
class PickHandler(osgGA.GUIEventHandler):
    def __init__(self, viewer, updateText):
        osgGA.GUIEventHandler.__init__(self)
        self._viewer = viewer;
        self._updateText = updateText;
        self._self = self

    def highlight(self, name):
        if self._updateText: self._updateText.setText(name)

    def handle(self, ea, aa):
        et = ea.getEventType()
        if et == osgGA.GUIEventAdapter.FRAME or et == osgGA.GUIEventAdapter.MOVE:
            #osg.notify(osg.NOTICE)<<"MOVE "<<ea.getX()<<ea.getY()<<std.endl
            picked_name = self.pick(ea.getX(),ea.getY())
            self.highlight(picked_name)
            return False
        elif et == osgGA.GUIEventAdapter.PUSH:
            #osg.notify(osg.NOTICE)<<"PUSH "<<ea.getX()<<ea.getY()<<std.endl
            picked_name = self.pick(ea.getX(),ea.getY())
            if len(picked_name):
                runApp(picked_name)
                return True
            else:
                return False
        else:
            return False


    def pick(self, x, y):
        hlist = osgUtil.IntersectVisitor.HitList()
        if self._viewer.computeIntersections(x, y, hlist):
            for hitr in hlist:
                if hitr._geode and len(hitr._geode.getName()):
                    return hitr._geode.getName()
        return ""

def createHUD(updateText):
    # create the hud. derived from osgHud.cpp
    # adds a set of quads, each in a separate Geode - which can be picked individually
    # eg to be used as a menuing/help system!
    # Can pick texts too!
    modelview_abs = osg.MatrixTransform()
    modelview_abs.setReferenceFrame(osg.Transform.ABSOLUTE_RF)
    modelview_abs.setMatrix(osg.Matrix.identity())

    projection = osg.Projection()
    projection.setMatrix(osg.Matrix.ortho2D(0,1280,0,1024))
    projection.addChild(modelview_abs)


    timesFont = "fonts/times.ttf"

    # turn lighting off for the text and disable depth test to ensure its always ontop.
    position = osg.Vec3(50.0,510.0,0.0)
    delta = osg.Vec3(0.0,-60.0,0.0)

    if 1:
    # this displays what has been selected
        geode = osg.Geode()
        stateset = geode.getOrCreateStateSet()
        stateset.setMode(GL_LIGHTING,osg.StateAttribute.OFF)
        stateset.setMode(GL_DEPTH_TEST,osg.StateAttribute.OFF)
        geode.setName("The text label")
        geode.addDrawable( updateText )
        modelview_abs.addChild(geode)

        updateText.setCharacterSize(20.0)
        updateText.setFont(timesFont)
        updateText.setColor(osg.Vec4(1.0,1.0,0.0,1.0))
        updateText.setText("")
        updateText.setPosition(position)

        position += delta

    return projection

defaultPos = osg.Vec3( 0.0, 0.0, 0.0 )
centerScope = osg.Vec3(0.0, 0.0, 0.0)

class Xample:
    def __init__(self, image, prog):
        self.texture = image
        self.app     = prog
        #osg.notify(osg.INFO) << "New Xample!" << std.endl

    def getTexture(self):
        return self.texture

    def getApp(self):
        return self.app


Xamplelist = []

def printList():
    print "start printList()"
    for x in Xamplelist:
        print "current x.texture = " + x.getTexture()
        print "current x.app = " + x.getApp()
    print "end printList()"

def runApp(xapp):
    print "start runApp()"
    for x in Xamplelist:
        if xapp == x.getApp():
            print "app found!"

            os.system(xapp)
            return 1
    print "app not found!"
    return 0


def readConfFile(confFile):
    print "Start reading confFile"

    fileName = osgDB.findDataFile(confFile)
    if len(fileName) == 0:
        print "Config file not found", confFile
        return

    infile = file(fileName)
    if not infile:
        print "File ", fileName, " can not be opened!"
        sys.exit(1)

    imageBuffer = ""
    appBuffer = ""

    while 1:
        imageBuffer = infile.readline()
        appBuffer = infile.readline()
        print imageBuffer, appBuffer
        if imageBuffer == None or appBuffer == None:
            break
        elif imageBuffer == "" or appBuffer == "":
            break
        else:
            print "imageBuffer: ", imageBuffer
            print "appBuffer: ", appBuffer

            tmp = Xample(imageBuffer[:-1], appBuffer[:-1])
            global Xamplelist
            Xamplelist.append(tmp)
    infile.close()

    print "End reading confFile"

    printList()

def SetObjectTextureState(geodeCurrent, texture):
    # retrieve or create a StateSet
    stateTexture = geodeCurrent.getOrCreateStateSet()

    # load texture.jpg as an image
    imgTexture = osgDB.readImageFile( texture )

    # if the image is successfully loaded
    if imgTexture:
        # create a two-dimensional texture object
        texCube = osg.Texture2D()

        # set the texture to the loaded image
        texCube.setImage(imgTexture)

        # set the texture to the state
        stateTexture.setTextureAttributeAndModes(0,texCube,osg.StateAttribute.ON)

        # set the state of the current geode
        geodeCurrent.setStateSet(stateTexture)
# end SetObjectTextureState


def createTexturedCube(fRadius,vPosition, texture, geodeName):
    # create a cube shape
    bCube = osg.Box(vPosition,fRadius)
    # osg.Box *bCube = osg.Box(vPosition,fRadius)

    # create a container that makes the cube drawable
    sdCube = osg.ShapeDrawable(bCube)

    # create a geode object to as a container for our drawable cube object
    geodeCube = osg.Geode()
    geodeCube.setName( geodeName )

    # set the object texture state
    SetObjectTextureState(geodeCube, texture)

    # add our drawable cube to the geode container
    geodeCube.addDrawable(sdCube)

    return geodeCube


def getPATransformation( obj, position, scale, pivot):
    tmpTrans = osg.PositionAttitudeTransform()
    tmpTrans.addChild( obj )

    tmpTrans.setPosition( position )
    tmpTrans.setScale( scale )
    tmpTrans.setPivotPoint( pivot )

    return tmpTrans

def printBoundings(current, name):
    currentBound = current.getBound()
    print name
    print "center = ", currentBound.center()
    print "radius = ", currentBound.radius()

#    return currentBound.radius()


def setupGraph():                                                                        # create Geodes/Nodes from Xamplelist    3
    xGroup = osg.Group()


#    positioning and sizes
    defaultRadius = 0.8

    itemsInLine    = 4;                                    # name says everything
    offset    = 0.05
    bs        = (defaultRadius / 4) + offset
    xstart    = (3*bs) * (-1)
    zstart    = xstart * (-1)
    xnext        = xstart
    znext        = zstart
    xjump        = (2*bs)
    zjump        = xjump
    vScale = osg.Vec3( 0.5, 0.5, 0.5 )
    vPivot = osg.Vec3( 0.0, 0.0, 0.0 )

#  run through Xampleliste
    z = 1
    for x in Xamplelist:
        tmpCube = createTexturedCube(defaultRadius, defaultPos, x.getTexture(), x.getApp())
        printBoundings(tmpCube, x.getApp())
        vPosition = osg.Vec3( xnext, 0.0, znext )
        transX = getPATransformation(tmpCube, vPosition, vScale, vPivot)
        xGroup.addChild( transX )

        # line feed
        if z < itemsInLine:
            xnext += xjump
        else:
            xnext = xstart
            znext -= zjump
            z = 0
    # end run through list

    return xGroup
# end setupGraph


def main(argv):
    if len(argv) <=1:
        readConfFile("osg.conf")                                                                          # read ConfigFile        1
    else:
        readConfFile(argv[1])                                                                          # read ConfigFile        1

    # construct the viewer.
    viewer = osgProducer.Viewer()

    # set up the value with sensible default event handlers.
    viewer.setUpViewer(osgProducer.Viewer.STANDARD_SETTINGS)

    updateText = osgText.Text()

    # add the handler for doing the picking
    viewer.getEventHandlerList().push_front(PickHandler(viewer,updateText))

    root = osg.Group()

    root.addChild( setupGraph() )

    # add the HUD subgraph.
    root.addChild(createHUD(updateText))

    # add model to viewer.
    viewer.setSceneData( root )

    # create the windows and run the threads.
    viewer.realize()

    lookAt = osg.Matrix()
    lookAt.makeLookAt(osg.Vec3(0.0, -4.0, 0.0), centerScope, osg.Vec3(0.0, 0.0, 1.0))

    #viewer.setView(lookAt)

    while not viewer.done():
        # wait for all cull and draw threads to complete.
        viewer.sync()

        # update the scene by traversing it with the the update visitor which will
        # call all node update callbacks and animations.
        viewer.update()

        # to be able to turn scene, place next call before viewer.update()
        viewer.setView(lookAt)


        # fire off the cull and draw traversals of the scene.
        viewer.frame()

    # wait for all cull and draw threads to complete before exit.
    viewer.sync()

    return 0

if __name__ == "__main__":
    import sys
    main(sys.argv)