"""
     pygl/dummyMG.py: CCP4MG Molecular Graphics Program
     Copyright (C) 2001-2008 University of York, CCLRC

     This library is free software: you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public License
     version 3, modified in accordance with the provisions of the 
     license to address the requirements of UK law.
 
     You should have received a copy of the modified GNU Lesser General 
     Public License along with this library.  If not, copies may be 
     downloaded from http://www.ccp4.ac.uk/ccp4license.php
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU Lesser General Public License for more details.
"""


import sys
from pygl_coord import *
from opengl import *
from point_funcs import *
import eventdefs
import time, threading
import Queue
import displayobject
import util
import jitter
import Light
import clip
from image_info import *
import string
import math
import cprim, pygl_coord
import glevent
import os
#import font_cache
import xmapview

class cube: 
  p0 = Cartesian(); p1 = Cartesian(); p2 = Cartesian(); p3 = Cartesian(); 
  p4 = Cartesian(); p5 = Cartesian(); p6 = Cartesian(); p7 = Cartesian(); 
  def __init__(self):
     pass

def nullfunc():
    pass

class GLUTThread(threading.Thread): 
    """
    An OpenGL/Glut thread class.
    This class is a high level self-standing data instance
    which uses the GLUT API to open and control a window 
    containing an OpenGL (or similar) context. 
    Instances of
    the class are intended to run in their own threads:
    GRAPHICS_thread = MG.GLUTThread()
    GRAPHICS_thread.setDaemon(1)
    GRAPHICS_thread.start()
    """

    NOGRAPHICS = 1
    x = 0
    y = 0

    pid = os.getpid()
    title = "CCP4 Molecular Graphics Program" + str(pid)

    RADIUS = 60.0
    drot = (0.0,0.0,0.0)
    quat = pygl_coord.Quat(0.0,0.0,0.0,0)
    win_w = 0;  win_h = 0
    screen_x, screen_y = 0,0
    
    rocking = 0

    resize = 0
    glready = threading.Event()    
    glpause = threading.Event()    
    jq = Queue.Queue(0)
    rotscalex = 1.0;  rotscaley = 1.0
    movescalex = 1.0;  movescaley = 1.0
    joyscalex = 0.0001;
    joyscaley = 0.0001;
    joybuttons = {}
    PERSPECTIVE = 0
    ORTHO = 1
    viewsize = 20
    xyratio = 1.0
    rpos = [0.0, 0.0, 0.0]
    dx = 0;  dy = 0;  dz = 0
    keyleft = 0#GLUT_KEY_LEFT
    keyright = 0#GLUT_KEY_RIGHT
    keyup = 0#GLUT_KEY_UP
    keydown = 0#GLUT_KEY_DOWN
    MOUSE = 1
    KEYBOARD = 2
    LEFT_MOTION = 3
    RIGHT_MOTION = 4
    MIDDLE_MOTION = 5
    WHEEL_UP = 6
    WHEEL_DOWN = 7
    SPECIAL = 8
    MENU = 9
    JOYSTICK_AXIS = 10
    KEYBOARD_UP = 11
    
    BUTTON_PRESSED = LEFT_MOTION

    CENTRE_ON_PRIMITIVE = 0
    LABEL_PRIMITIVE = 1

    NOSTEREO = 0
    REDBLUE = 1
    REDGREEN = 2
    REDCYAN = 3
    BLUERED = 4
    GREENRED = 5
    CYANRED = 6
    QUADBUFFER = 7
    SIDEBYSIDE = 8
    LEFTSTEREOONLY = 10
    RIGHTSTEREOONLY = 9
    SHIFT = 0
    CTRL = 1
    ALT = 2
    ROTATION_STEREO=0
    SHEAR_STEREO=1
    stereo_view_style = ROTATION_STEREO
    screenshot_filename="screendump.ppm"
    ps_filename="screendump.ps"
    ps_paper = "A4"
    pov_filename="screendump.pov"
    dumpbitmap = 0
    dumpps = 0
    dumppov = 0
    modifiers = [0,0,0]
    section = 0

    start_width = 100; start_height = 100 
    rubber_band_start = (-5,-5)
    rubber_band_end = (start_width+5,start_height+5)
    rubber_band_box = cube()

    near_min = 1
    far_max = 1000
    fog_far_max = 2000
    min_slab_delta=2.0
    NEAR = near_min
    FAR = far_max
    FOG_START=25
    FOG_END=90
    projectmode = ORTHO
    stereo_on = 0
    stereo_mode = SIDEBYSIDE
    if stereo_view_style == ROTATION_STEREO:
      stereoseparation = 10; 
    else:
      stereoseparation = 1.5; 
    hardware_stereo_available = 0
    stereo_angle = 6
    shear = .02
    antialias = 0
    antialias_screenshot = 0
    ACSIZE=15
    fog_on = 1
    fog_density = 0.015
    fog_mode = GL_EXP2
    #fog_mode = GL_LINEAR
    lighting = 1

    IMMEDIATE = 0
    DISPLAYLISTS = 1
    VERTEXARRAY = 2
    #rendermode = IMMEDIATE
    rendermode = DISPLAYLISTS

    draw_symmetry = 0
    symm_diff_colour = 0

    multiview = 0

    joy_x = 0
    joy_y = 0

    nframes = 0
    previous_frames = nframes
    initial_time = time.time()
    previous_time = initial_time
    show_fps = 0
    show_axes = 0
    moving = 0

    smooth_line = 1
    smooth_polygons = 0

    mouse_event = []

    screen_box = ""

    do_exit = 0

    reparented = 0
 
    diagnostic = {
      'opengl':0 }
    
    set_camera_glide = 1
    set_camera_reset_radius = 1
    set_camera_zoom_radius = 10.0
    set_camera_time = 1.0

    background_alpha = 1.0

    redraw = 1

    keyboard_is_active = 0
    special_is_active = 0

    offscreen_buffer = 0
    onscreen_buffer = 0
    mirror_buffers = 0
    default_output_buffer = 0
    offscreen_buffer_override = 0

    use_transparency = 0

    gl_renderer = ''

    update_matrices = 0
    click_timer = threading.Timer(0.0,nullfunc)
    click_timer.start()

    axes_x = ''
    axes_y = ''
    axes_z = ''

    render_quality = 0
    request_render_quality = 1
    fsaa_on = 0

    frame_count = '-1'
    idle_pause = 0.2

    cue_text = 1

    screenshot_width = -1
    screenshot_height = -1

    slab_width = 6
    slab_on = 0

    def IdleFunction(self):
        return

    def CheckErrors(self,info=""):
        return

    def setup_colour_pointers(self):
        return

    def IsPointOnScreen(self,o):
        return

    def set_viewsize(self,viewsize=''):
        return

    def set_camera_origin(self,**keywords):
        return
            
    def TransformBetweenTwoViews(self,o1,o2,q1,q2):
        return

    def glutinit(self):
        return

    def TestIfGLIsBroken(self):
        return

    def __init__(self):
        """
        Constructor, setting initial variables.
        """
        self._stopevent = threading.Event()
        self._sleepperiod = 1.0

        self.glevent = glevent.GLEvent(self)

        threading.Thread.__init__(self, name="Glut Thread")
        self.fps_text = ''
        self.fps_prim = cprim.BillBoardText(pygl_coord.Cartesian(0.02,0.02,0),self.fps_text,pygl_coord.Cartesian(0,0,0))
        self.fps_prim.SetFontSize(24)
        """
        Sets up GLUT callbacks, opens window, etc.
        """

        #self.key_presses = IntVector(128)
	self.key_presses = []
	for i in range(128):
          self.key_presses.append(0)
        #self.old_key_presses = IntVector(128)
	self.old_key_presses = []
	for i in range(128):
          self.old_key_presses.append(0)
        #self.special_presses = IntVector(128)
	self.special_presses = []
	for i in range(128):
          self.special_presses.append(0)
        #self.old_special_presses = IntVector(128)
	self.old_special_presses = []
	for i in range(128):
          self.old_special_presses.append(0)

        self.setup_colour_pointers()

        if self.diagnostic['opengl']: print "%s starts" % (self.getName(),)
        self.win_w = self.start_width
        self.win_h = self.start_height

        import COLOUR

        self.bgcolor = COLOUR.COLOUR.insts.RGB("black")

        rgbreps = cprim.RGBReps()
        col = COLOUR.COLOUR.insts.RGB('default')
        rgbreps.AddColour('default',col[1],col[2],col[3])
        exclude = []
        next = COLOUR.COLOUR.insts.next('default')
        while exclude.count(next) == 0:
          col = COLOUR.COLOUR.insts.RGB(next)
          rgbreps.AddColour(next,col[0],col[1],col[2],col[3])
          exclude.append(next)
          next = COLOUR.COLOUR.insts.next(next)

        self.dl_lines = []
        self.dl_solids = []
	self.rebuild_lists = 0
   
    def Exit(self):
        return

    def clear(self):
        return
        
    def addobj(self,displayobj):
        return

    def deleteobj(self,id):
        return
        
    def registerqueue(self,jq='',interrupt=''):
        return

    def setup_clipping(self):
        return

    def initialize_clipping(self):
        return

    def get_lighting_params(self):
        return

    def set_lighting_params(self,params=[]):
        return
        
    def initialize_lighting(self,params=[]):
        return

    def setup_lighting(self):
        return
        
    def print_glinfo(self):
        return
        
    def simple_orient(self):
        return

    def run(self):
        return

    def join(self,timeout=None):
        return
        """
        Stop the thread. Shouldn't ever get here.
        """
        self.stop = 1;
        self._stopevent.set()
        threading.Thread.join(self, timeout)

    def toggle_rocking(self):
        return

    def CheckKeysAndMouseStatus(self):
        return

    def buildlist(self,listid):
        return

    def switch_projection(self):
        return

    def DrawRubberBand(self):
        return

    def SetStereoMode(self,stereo_mode):
        return

    def SetAxes(self,axes_on):
        return

    def SetFog(self,fog_on):
        return

    def SetStereo(self,stereo_on):
        return

    def BuildPrimitiveDisplayList(self):
        return

    def SetDefaultOutputBuffer(self):
        return

    def SetOffScreenBuffer(self,buffer):
        return

    def BuildLists(self,force=0):
        return

    def CalculateJitter(self):
        return

    def Jitter(self,acsize,xoff,yoff,jarray,jit,axes):
        return

    def SetTransparency(self,transparency=-1):
        return

    def drawlists(self):
        return

    def DrawPostscript(self,psfilename="",paper=""):
        return

    def DrawPovRay(self,filename=""):
        return

    def draw(self,transparent,text=0):
        return

    def draw_lines(self,transparent,text=0):
        return

    def draw_solids(self,transparent,text=0):
        return

    def setmaxviewsize(self,size):
        return

    def UnDefineSlab(self):
        return

    def DefineSlab(self,width='',turn_on='',**keywords):        
        return

    def MoveSlab(self,dist):
        return

    def ExpandSlab(self,delta):
        return

    def GetWindowSize(self):
        return [800,800]

    def set_default_clip_planes(self,near,far):
        return

    def SetScreenSection(self,section):
        return

    def changeSize(self,w,h):
        return
   
    def applystereoshear(self,obj):
        return

    def applystereorotation(self,obj):
        return

    def copyrotation(self,obj1,obj2):
        return

    def resetrotation(self,obj):
        return

    def applyorthorotations(self,obj):
        return

    def applyrotation(self,obj):
        return

    def getaxes(self):
        return

    def setup_fog(self):
        return
        
    def set_colourmask(self,eye):
        return

    def DrawAxes(self,glrotmat,w,h):
        return

    def draw_scene(self,w,h):
        return

    def orient(self):
        return

    def movexyz(self,r,dr):
        return

    def calculate_extents(self):
        return

    def getdxdydz(self,dx,dy,dz):
        return

    def bgcolour(self,colour):
        return

    def zoom_camera(self,zoom):
        return

    def SetRotation(self,q=''):
        return
        
    def move_camera(self,dx,dy,dz):
        return

    def move_camera_scale(self,dx,dy,dz):
        return
      
    def rotate_camera(self,drot):
        return

    def getmodifiers(self):
        return

    def GetWorldXY(self):
        return
 
    def GetScreenBox(self):
        return

    def GetXYZBox(self, x, y):
        return

    def mouse(self, button, state, x, y):
        return
    
    def ClearMouseEvents(self):
        return
 
    def entry(self, state):
        return

    def keyboard_up(self, key, x, y):
        return
        
    def keyboard(self, key, x, y):
        return
    
    def special(self, key, x, y):
        return

    def special_up(self, key, x, y):
        return
    
    def passive(self, x, y):
        return

    def SendMotionEvent(self,dx,dy,x,y):
        return

    def motion(self, x, y):
        return

    def getxyz(self,x,y): 
        return

    def get_pixdata(self):
        return

    def screenshot(self,name=""):
        return

    def request_screenshot(self,filename="screendump.ppm",antialias=0,sections=0,blocking=1,width=-1,height=-1,render_quality=1):
        return
        
    def request_screenshot_ps(self,filename="screendump.ps"):
        return

    def request_screenshot_pov(self,filename="screendump.pov"):
        return

    def UnPause(self):
        return

    def Pause(self,hard=0):
        return

    def Wait(self):
        return

    def Flush(self):
        return

    def set_rubber_band_start(self,x,y):
        return

    def set_rubber_band_end(self,x,y):
        return

    def define_rubber_band_cube(self):
        return

    def get_clipping_planes(self):
        return

    def get_rubber_band_planes(self):
        return