RepresentationOldGUI.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;
using UI;
using Molecule.Model;
using Molecule.View;
using System.Collections.Generic;

public class RepresentationOldGUI {


    public static bool showMetaphorType = false;
    public static bool showAtomType = false;
    public static bool showBondType = false;
    public static bool showHyperballsMenu = false;
    public static bool showCubeLineBondMenu = false ;


    public  static   bool transMETAPHOR = false;
    public  static   float deltaShrink;
    public  static   float deltaScale;
    public  static   float deltaRadius;
    public  static   float newShrink;
    public  static   float newScale;
    public  static   float newGlobalRadius = 1.0f;
    public  static   float transDelta = 25.0f;


    public static float shrink = 0.4f;
    public static float globalRadius = 0.35f;
    public static float linkScale = 1.0f;
    public static float bondWidth = 0.15f ; // default bond width for cube/line
    public static float shininess = 0f;

    public static Molecule3D m3d = GameObject.Find ("LoadBox").GetComponent<Molecule3D> ();

    public static void AtomStyle (int a) {
        LoadTypeGUI.SetTitle("Choose Atom Style");
        
        GUILayout.BeginHorizontal();
        if (GUILayout.Button (new GUIContent ("Cube", "Use cubes to represent atoms"))) {   
            
            Debug.Log("Cube representation");


            DisplayMolecule.ChangeRepresentation(UIData.AtomType.cube,UIData.BondType.nobond);

            showAtomType = false;
            LoadTypeGUI.toggle_NA_HIDE = false; // whether molecule must be hidden (I think)
            LoadTypeGUI.toggle_NA_CLICK = false;
            BallUpdate.resetColors = true;
        }
        
        if (GUILayout.Button (new GUIContent ("Sphere", "Use triangulated spheres to represent atoms"))) {
            
            Debug.Log("Sphere representation");

            DisplayMolecule.ChangeRepresentation(UIData.AtomType.sphere,UIData.BondType.nobond);

            showAtomType = false;
            LoadTypeGUI.toggle_NA_HIDE = false;
            LoadTypeGUI.toggle_NA_CLICK = false;
            BallUpdate.resetColors = true;
        }
        GUILayout.EndHorizontal ();
        
        
        GUILayout.BeginHorizontal ();
        if (GUILayout.Button (new GUIContent ("Hyperball", "Use the HyperBalls shader to render atoms"))) {
            
            Debug.Log("HyperBall representation");

            DisplayMolecule.ChangeRepresentation(UIData.AtomType.hyperball,UIData.bondtype);

            showAtomType = false;
            LoadTypeGUI.toggle_NA_HIDE = false;
            LoadTypeGUI.toggle_NA_CLICK = false;
            BallUpdate.resetColors = true;
        }
        

        if (GUILayout.Button (new GUIContent ("Particle", "Use the ParticleBall shader to represent atoms"))) {
            

            DisplayMolecule.ChangeRepresentation(UIData.AtomType.particleball,UIData.BondType.nobond);


            showAtomType = false;
            LoadTypeGUI.toggle_NA_HIDE = false;
            LoadTypeGUI.toggle_NA_SWITCH = false;
            LoadTypeGUI.toggle_NA_CLICK = false;

        }
        GUILayout.EndHorizontal ();
        GUILayout.BeginHorizontal ();

        if (GUILayout.Button (new GUIContent ("Optimized Hyperball", "Use the Optimized HyperBalls shader to render atoms"))) {
            Debug.Log("Optimized Hyperball representation");


            if(UIData.bondtype==UIData.BondType.hyperstick)
                DisplayMolecule.ChangeRepresentation(UIData.AtomType.optihb,UIData.BondType.optihs);

            else
                DisplayMolecule.ChangeRepresentation(UIData.AtomType.optihb,UIData.bondtype);


            showAtomType = false;
            LoadTypeGUI.toggle_NA_HIDE = false;
            LoadTypeGUI.toggle_NA_CLICK = false;

        }

        GUILayout.EndHorizontal ();



        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
        
        GUI.DragWindow();
    } // end of AtomStyle
    
    private static void MetaphorControl () {
        GUILayout.BeginHorizontal ();
        if (GUILayout.Button (new GUIContent ("Metaphor", "Change HyperBalls parameters to values for standard representations")))
            showMetaphorType = !showMetaphorType;
        GUILayout.EndHorizontal ();
        
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
    }
    


    public static void Bond (int a) {
        LoadTypeGUI.SetTitle("Bond Style");
        
//          if(UIData.atomtype==UIData.AtomType.particleball&&!UIData.openAllMenu)GUI.enabled=false;
        GUILayout.BeginHorizontal ();
        GUILayout.FlexibleSpace();
        if (GUILayout.Button (new GUIContent ("Cube", "Use Cubes to represent bonds"), GUILayout.Width(Rectangles.atomButtonWidth))) {
            showBondType = false;
            DisplayMolecule.ChangeRepresentation(UIData.atomtype,UIData.BondType.cube);

        }

        if (GUILayout.Button (new GUIContent ("Line", "Use the Line renderer to represent bonds"), GUILayout.Width(Rectangles.atomButtonWidth))) {
            showBondType = false;
            DisplayMolecule.ChangeRepresentation(UIData.atomtype,UIData.BondType.line);

        }
        GUILayout.FlexibleSpace();
        GUILayout.EndHorizontal ();
        
        GUILayout.BeginHorizontal ();
        GUILayout.FlexibleSpace();
        if (GUILayout.Button (new GUIContent ("HyperStick", "Use the HyperStick shader to represent bonds"), GUILayout.Width(Rectangles.atomButtonWidth))) {    
            showBondType = false;
            DisplayMolecule.ChangeRepresentation(UIData.atomtype,UIData.BondType.hyperstick);

        }

        if (GUILayout.Button (new GUIContent ("No Stick", "Do not render any bonds"), GUILayout.Width(Rectangles.atomButtonWidth))) {
            showBondType = false;
            DisplayMolecule.ChangeRepresentation(UIData.atomtype,UIData.BondType.nobond);

        }
        GUILayout.FlexibleSpace();
        GUILayout.EndHorizontal ();

        GUILayout.BeginHorizontal ();

        if (GUILayout.Button (new GUIContent ("Optimized HyperStick", "Use the Optimized HyperBalls shader to render sticks"))) {
            showBondType = false;
            DisplayMolecule.ChangeRepresentation(UIData.AtomType.optihb,UIData.BondType.optihs);
        }

        GUILayout.EndHorizontal ();


        GUI.enabled = true;
        
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
        
        GUI.DragWindow();
    } // end of Bond


    public static void CubeLineBond (int a){
        LoadTypeGUI.SetTitle("Bond Width");

        bondWidth = LoadTypeGUI.LabelSlider(bondWidth, 0.00001f, 0.5f, "Width: " + bondWidth.ToString("0.00"), 
                "Determines width of bonds for Cubes and Lines", true, (int)(0.90 * Rectangles.cubeLineBondTypeWidth), 1, true);
        BondCubeUpdate.width = bondWidth;
        LineUpdate.width = bondWidth;
        GUI.enabled = true;
        GUI.DragWindow();
    }
    


        
    public static void Metaphor (int a) {
        showMetaphorType = LoadTypeGUI.SetTitleExit("Metaphor");
        
        GUILayout.BeginHorizontal ();
        if (GUILayout.Button (new GUIContent ("CPK", "CPK representation as balls and sticks"))) {
            newGlobalRadius = 0.2f;
            deltaRadius = (newGlobalRadius - globalRadius) / transDelta;
            newShrink = 0.0001f;
            deltaShrink = (newShrink - shrink) / transDelta;
            newScale = 0.3f;
            deltaScale = (newScale - linkScale) / transDelta;
            transMETAPHOR = true;
        }
        GUILayout.EndHorizontal ();
        
        GUILayout.BeginHorizontal ();
        
        if (GUILayout.Button (new GUIContent ("Licorice", "Licorice representation of the molecule"))) {
            newGlobalRadius = 0.1f;
            deltaRadius = (newGlobalRadius - globalRadius) / transDelta;
            newShrink = 0.0001f;
            deltaShrink = (newShrink - shrink) / transDelta;
            newScale = 1.0f;
            deltaScale = (newScale - linkScale) / transDelta;
            transMETAPHOR = true;
        }                       
        GUILayout.EndHorizontal ();
        GUILayout.BeginHorizontal ();
        
        if (GUILayout.Button (new GUIContent ("VdW", "van der Waals representation as spacefilling spheres"))) {
            newGlobalRadius = 1.0f;
            deltaRadius = (newGlobalRadius - globalRadius) / transDelta;
            newShrink = 0.8f;
            deltaShrink = (newShrink - shrink) / transDelta;
            newScale = 0.0f;
            deltaScale = (newScale - linkScale) / transDelta;
            transMETAPHOR = true;
        }
        GUILayout.EndHorizontal ();
        GUILayout.BeginHorizontal ();
        
        if (GUILayout.Button (new GUIContent ("Smooth", "Smooth HyperBalls metaphor representation"))) {
            newGlobalRadius = 0.35f;
            deltaRadius = (newGlobalRadius - globalRadius) / transDelta;
            newShrink = 0.4f;
            deltaShrink = (newShrink - shrink) / transDelta;
            newScale = 1.0f;
            deltaScale = (newScale - linkScale) / transDelta;
            transMETAPHOR = true;   
        }                       
        GUILayout.EndHorizontal ();
        GUILayout.BeginHorizontal ();
        
        if (GUILayout.Button (new GUIContent ("SmoothLink", "SmoothLink HyperBalls representation"))) {
            newGlobalRadius = 0.4f;
            deltaRadius = (newGlobalRadius - globalRadius) / transDelta;
            newShrink = 0.5f;
            deltaShrink = (newShrink - shrink) / transDelta;
            newScale = 1.0f;
            deltaScale = (newScale - linkScale) / transDelta;
            transMETAPHOR = true;   
        }                       
        GUILayout.EndHorizontal ();
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
        GUI.DragWindow();
    } // End of Metaphor



    
    private static void PhysicalChoice () {
        GUILayout.BeginHorizontal ();
        GUILayout.Label ("Velocity Colors:");
        GUILayout.EndHorizontal ();
        
        GUILayout.BeginHorizontal ();
        
        UIData.toggleGray = GUILayout.Toggle (UIData.toggleGray, "Gray");
        if (UIData.toggleGray)
            UIData.toggleColor = false;
        else
            UIData.toggleColor = true;
        
        UIData.toggleColor = GUILayout.Toggle (UIData.toggleColor, "Normal");
        if (UIData.toggleColor)
            UIData.toggleGray = false;
        else
            UIData.toggleGray = true;
        
        GUILayout.EndHorizontal ();
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
    }
    
    
    public static void HyperballStyle (int a) {

        LoadTypeGUI.SetTitle("Hyperball Style");

        int sliderWidth = (int)(0.40 * Rectangles.hyperballWidth);
        shrink = LoadTypeGUI.LabelSlider (shrink, 0.00001f, 0.99f, "Shrink " + shrink.ToString("0.00"),
            "Determines shrink factor parameter for HyperBalls", true, sliderWidth, 1);
        
//          toggle_HB_RANIM = GUILayout.Toggle (toggle_HB_RANIM, new GUIContent ("HB_RANIM", "Animate radius parameter"));
        linkScale = LoadTypeGUI.LabelSlider (linkScale, 0.00001f, 1.0f, "Scale " + linkScale.ToString("0.00"),
            "Determines scale parameter", true, sliderWidth, 1);
        
        LoadTypeGUI.depthfactor = LoadTypeGUI.LabelSlider (LoadTypeGUI.depthfactor, -3.0f, 3.0f, "DFactor " + LoadTypeGUI.depthfactor.ToString("0.00"),
            "Determines depth factor for network visualization", MoleculeModel.networkLoaded, sliderWidth, 1);
        GUI.enabled = true;
        
        if(GUI.changed){
            HStickMeshManager.resetShrink = true;
            HStickMeshManager.resetScale = true;
        }


        MetaphorControl ();
    
        if(UIData.atomtype != UIData.AtomType.hyperball){
            GUI.enabled = false;
            LoadTypeGUI.toggle_NA_INTERACTIVE = false;
        }
        LoadTypeGUI.toggle_NA_INTERACTIVE = GUILayout.Toggle (LoadTypeGUI.toggle_NA_INTERACTIVE, new GUIContent ("Interactive mode", "Toggle interactive mode, the physics engine will be used"));
        

        GUI.enabled = true;
        LoadTypeGUI.drag = LoadTypeGUI.LabelSlider (LoadTypeGUI.drag, 0.00001f, 5f, "Drag " + LoadTypeGUI.drag.ToString("0.00"), "Determines PhysX engine drag value", 
                                UIData.interactive, sliderWidth, 1);
        LoadTypeGUI.spring = LoadTypeGUI.LabelSlider (LoadTypeGUI.spring, 0.00001f, 20, "Spring " + LoadTypeGUI.spring.ToString("0.00"), "Determines PhysX engine spring constant",
                                UIData.interactive, sliderWidth, 1);
        PhysicalChoice();
//          LoadTypeGUI.toggle_NA_INTERACTIVE=false;
        GUI.enabled = true; 
        
        GUILayout.BeginHorizontal();
        LoadTypeGUI.toggle_NA_MEASURE = GUILayout.Toggle (LoadTypeGUI.toggle_NA_MEASURE, new GUIContent ("Measure dist.", "Toggle mouse clicking to measure the distance between two atoms"));
        GUILayout.EndHorizontal();
        
        GUILayout.BeginHorizontal();
        LoadTypeGUI.toggle_DISTANCE_CUEING = GUILayout.Toggle (LoadTypeGUI.toggle_DISTANCE_CUEING, new GUIContent ("Dist. cueing", "Toggle distance cueing, which darkens distant objects"));
        GUILayout.EndHorizontal();
        
        if(LoadTypeGUI.toggle_DISTANCE_CUEING) {
            if(!LoadTypeGUI.distanceCueingEnabled){
                DisplayMolecule.ToggleDistanceCueing(true);
                LoadTypeGUI.distanceCueingEnabled = true;
            }
        }
        else{
            if(LoadTypeGUI.distanceCueingEnabled) {
                DisplayMolecule.ToggleDistanceCueing(false);
                LoadTypeGUI.distanceCueingEnabled = false;
            }
        }

        LoadTypeGUI.fov_angle = LoadTypeGUI.LabelSlider (LoadTypeGUI.fov_angle, 10f, 120f, "FOV " + LoadTypeGUI.fov_angle.ToString("0.00") + "°", "Set camera FOV angle",
            true, sliderWidth, 1);

        if(LoadTypeGUI.fov_angle != LoadTypeGUI.previous_angle)
        {
            LoadTypeGUI.previous_angle = LoadTypeGUI.fov_angle;
            m3d.SetFOV(LoadTypeGUI.fov_angle);
        }

        //Alex :
        //TODO : LOD mode buggy with other representation than Hyperball

        GUI.enabled = true;
        if (!LoadTypeGUI.toggle_NA_MEASURE && LoadTypeGUI.mainCamera.GetComponent<MeasureDistance> ())
            LoadTypeGUI.mainCamera.GetComponent<MeasureDistance> ().enabled = false;
        else if (LoadTypeGUI.toggle_NA_MEASURE && LoadTypeGUI.mainCamera.GetComponent<MeasureDistance> ())
            LoadTypeGUI.mainCamera.GetComponent<MeasureDistance> ().enabled = true;
//          GUILayout.EndHorizontal();
        


        
        if (LoadTypeGUI.toggle_NA_INTERACTIVE && UIData.atomtype == UIData.AtomType.hyperball) {
            UIData.interactive = true;
            UIData.resetInteractive = true;
        } else {
            UIData.toggleGray = false;
            UIData.toggleColor = true;
            UIData.interactive = false;
            //UIData.resetInteractive = true;
            if (!MoleculeModel.fieldLineFileExists)
                LoadTypeGUI.showGrayColor = false;
            if (!MoleculeModel.surfaceFileExists)
                LoadTypeGUI.showSurfaceButton = false;
        }
        // if (Event.current.type == EventType.Repaint)
            // MoleculeModel.newtooltip = GUI.tooltip;

        GUI.DragWindow();
    } // End of HyperballStyle
    
    
        
    private static void RenderingParameters () {
//          toggle_HB_SANIM = GUILayout.Toggle (toggle_HB_SANIM, new GUIContent ("HB_SANIM", "Animate shrink parameter"));
        
        GUILayout.BeginHorizontal();
        GUILayout.Label("Color/Texture/Scale"); // Make a little more place between the representation selection and the rendering parameters
        GUILayout.EndHorizontal();
        
        GUILayout.BeginHorizontal ();
        GUILayout.FlexibleSpace(); // so as to center the buttons
        if (GUILayout.Button (new GUIContent ("Renderer", "Choose the color, texture and scale of each atom"), GUILayout.Width(Rectangles.atomButtonWidth))){
            LoadTypeGUI.showSetAtomScales = !LoadTypeGUI.showSetAtomScales;
            LoadTypeGUI.showAtomsExtendedMenu = false;
            LoadTypeGUI.showResiduesMenu = false;
            LoadTypeGUI.showChainsMenu = false;
            GUIDisplay.applyToAtoms.Add("All");
        }
        
        if (GUILayout.Button (new GUIContent ("Panels", "Open colors and textures panels menu"), GUILayout.Width(Rectangles.atomButtonWidth))) {
            LoadTypeGUI.showPanelsMenu = !LoadTypeGUI.showPanelsMenu;
        }
        
        GUILayout.FlexibleSpace();
        GUILayout.EndHorizontal ();
        
        GUILayout.BeginHorizontal();
        GUI.enabled = true;
        bool wasHide = LoadTypeGUI.toggle_NA_HIDE;
        LoadTypeGUI.toggle_NA_HIDE = GUILayout.Toggle (LoadTypeGUI.toggle_NA_HIDE, new GUIContent ("Hide", "Hide/Display atoms")); // && !carbon_alpha?
        if(wasHide != LoadTypeGUI.toggle_NA_HIDE){
            if(LoadTypeGUI.toggle_NA_HIDE)
                DisplayMolecule.HideMolecule();
            else
                DisplayMolecule.ShowMolecule();

        }


        UIData.shadow = GUILayout.Toggle (UIData.shadow, new GUIContent ("Shadows", "Display shadows"));

        if(GUI.changed){
            GenericManager managerAtom = UnityMolMain.getCurrentAtomManager();
            if(UIData.shadow)
                managerAtom.EnableShadows();
            else
                managerAtom.DisableShadows();
        
            GenericManager managerBond = UnityMolMain.getCurrentBondManager();
            if(UIData.shadow)
                managerBond.EnableShadows();
            else
                managerBond.DisableShadows();
        }

        GUILayout.EndHorizontal();
        
        float tmpRadius = globalRadius;
        tmpRadius = LoadTypeGUI.LabelSlider (tmpRadius, 0.00001f, 2.0f, "Radius " + tmpRadius.ToString("0.00"), "Determines radius value", true, (int)(0.90 * Rectangles.atomMenuWidth), 1, true);
        
        if(tmpRadius != globalRadius){
            globalRadius = tmpRadius;
            HBallMeshManager.resetRadii = true;
        }
        
        if (LoadTypeGUI.toggle_NA_HBALLSMOOTH) {
            LoadTypeGUI.m_colorPicker = null;

            showAtomType = false;               
            BallUpdate.resetColors = true;
            BallUpdate.resetRadii = true;
            showBondType = false;
            DisplayMolecule.ChangeRepresentation(UIData.AtomType.hyperball,UIData.BondType.hyperstick);

            linkScale = 1.0f;
            
            LoadTypeGUI.toggle_NA_HBALLSMOOTH = false;
            UIData.hballsmoothmode = false;
        }

        GUILayout.BeginHorizontal();

        bool tmpHydro = LoadTypeGUI.toggle_HIDE_HYDROGEN;
        LoadTypeGUI.toggle_HIDE_HYDROGEN = GUILayout.Toggle (LoadTypeGUI.toggle_HIDE_HYDROGEN, new GUIContent ("Hide hydrogens", "Toggles the hide hydrogens function"));

        if(tmpHydro != LoadTypeGUI.toggle_HIDE_HYDROGEN){
            DisplayMolecule.showHydrogens(LoadTypeGUI.toggle_HIDE_HYDROGEN);            
        }
        GUILayout.EndHorizontal();

        

        GUILayout.BeginHorizontal();
        if(LoadTypeGUI.toggle_NA_HIDE || UIData.atomtype == UIData.AtomType.particleball)
            GUI.enabled = false;
        LoadTypeGUI.toggle_NA_SWITCH = GUILayout.Toggle (LoadTypeGUI.toggle_NA_SWITCH, new GUIContent 
            ("LOD mode", "Toggle LOD.  When this is enabled and the molecule is moving, hyperboloids are replaced by particle balls for smoother framerates."));
        UIData.switchmode = LoadTypeGUI.toggle_NA_SWITCH;
        GUI.enabled = true;
        if(LoadTypeGUI.toggle_NA_HIDE)
            GUI.enabled = false;
        LoadTypeGUI.toggle_NA_AUTOMOVE = GUILayout.Toggle (LoadTypeGUI.toggle_NA_AUTOMOVE, new GUIContent ("Automove", "Camera auto rotation"));
        GUI.enabled = true;
        GUILayout.EndHorizontal();
        

        const float maxshine = 200f;
        float tmpShininess = shininess;


        if(UIData.atomtype == UIData.AtomType.hyperball || UIData.atomtype == UIData.AtomType.optihb){


            tmpShininess = LoadTypeGUI.LabelSlider (tmpShininess, 0f, maxshine, "Shininess " + tmpShininess.ToString("0.00"), "Determines shininess for hyperballs", true, (int)(0.90 * Rectangles.atomMenuWidth), 1, true);


            if(tmpShininess != shininess){
                shininess = tmpShininess;
                float correctedShininess = 0.0f;
                if(shininess != 0.0f){ //Shininess is strong when just over 0 and gets weaker after
                    //corrected shininess is ranged from 1f to nearly 200.9999...f
                    correctedShininess = (maxshine+1f) - shininess;
                }

                HBallManager.shininess = correctedShininess;
                HBallManager.resetShininess = true;
                HBallMeshManager.shininess = correctedShininess;
                HBallMeshManager.resetShininess = true;
            }
        }
        GUI.enabled = true;

        // GUI.enabled = true;
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;

    }
        


    public static void SetAtomStyle () {            
        
        GUILayout.BeginHorizontal ();
        GUILayout.FlexibleSpace();
        GUILayout.Label("Atom Style", GUILayout.Width(Rectangles.atomButtonWidth));
        GUILayout.Label("Bond Style", GUILayout.Width(Rectangles.atomButtonWidth));
        GUILayout.FlexibleSpace();
        GUILayout.EndHorizontal ();

        GUILayout.BeginHorizontal ();
        GUILayout.FlexibleSpace();
        string atomtype = "";
        UIData.AtomType atype = UIData.atomtype;
        if(atype == UIData.AtomType.noatom)
            atype = LoadTypeGUI.Molecule3DComp.PreviousAtomType;
        switch (atype) {
        case UIData.AtomType.cube:
            atomtype = "Cube";
            break;
        case UIData.AtomType.sphere:    
            atomtype = "Sphere";
            break;
        case UIData.AtomType.hyperball:
            atomtype = "HyperBall";
            break;
        case UIData.AtomType.raycasting:
            atomtype = "Raycasting";
            break;
        case UIData.AtomType.billboard:
            atomtype = "Common Billboard";
            break;
        case UIData.AtomType.rcbillboard:
            atomtype = "RayCasting Billboard";
            break;
        case UIData.AtomType.hbbillboard:
            atomtype = "HyperBall Billboard";
            break;
        case UIData.AtomType.rcsprite:
            atomtype = "RayCasting Sprite";
            break;
        case UIData.AtomType.multihyperball:
            atomtype = "Multi-Hyperball";
            break;
        case UIData.AtomType.combinemeshball:
            atomtype = "CombineMesh HyperBall";
            break;
        case UIData.AtomType.particleball:
            atomtype = "ParticleBall";
            break;
        case UIData.AtomType.particleballalphablend:
            atomtype = "ParticleBallAlpahBlend";
            break;
        case UIData.AtomType.optihb:
            atomtype = "Optimized Hyperball";
            break;
        }

        string displayAtomType;
        if (atomtype == "ParticleBall")
            displayAtomType = "Particle";
        else
            displayAtomType = atomtype;
        if (GUILayout.Button (new GUIContent (displayAtomType, "Change the atom appearance style or rendering method"), GUILayout.Width(Rectangles.atomButtonWidth))) {
            showAtomType = !showAtomType;
            showBondType = false;
            LoadTypeGUI.m_colorPicker = null;
        }


        string bondtype = "";
        switch (UIData.bondtype) {
        case UIData.BondType.cube:
            bondtype = "Cube";
            break;
        case UIData.BondType.line:
            bondtype = "Line";
            break;
        case UIData.BondType.hyperstick:
            bondtype = "HyperStick";
            break;
        case UIData.BondType.tubestick:
            bondtype = "TubeStick";
            break;
        case UIData.BondType.bbhyperstick:
            bondtype = "Billboard HyperStick";
            break;
        case UIData.BondType.particlestick:
            bondtype = "Particle Stick";
            break;
        case UIData.BondType.nobond:
            bondtype = "No Stick";
            break;
        case UIData.BondType.optihs:
            bondtype = "Optimized HyperStick";
            break;
        }

        
        if (GUILayout.Button (new GUIContent (bondtype, "Change the bond appearance style or rendering method"), GUILayout.Width(Rectangles.atomButtonWidth))) {    
            showBondType = !showBondType;
            showAtomType = false;
        }
        GUILayout.FlexibleSpace();
        GUILayout.EndHorizontal ();
        
        GUILayout.BeginHorizontal();
        if(LoadTypeGUI.toggle_NA_HIDE)
            GUI.enabled = false;

        if(GUILayout.Button(new GUIContent("Smooth HyperBalls", "Set a parameter combo for HyperBalls and Sticks with SmoothLinks once"))) {
            LoadTypeGUI.toggle_NA_HBALLSMOOTH = !LoadTypeGUI.toggle_NA_HBALLSMOOTH;
            UIData.hballsmoothmode = LoadTypeGUI.toggle_NA_HBALLSMOOTH;
        }
        GUILayout.EndHorizontal();
        GUILayout.BeginHorizontal();
        if(GUILayout.Button(new GUIContent("Optimized HyperBalls", "Create a mesh for an effective rendering method"))) {

            DisplayMolecule.ChangeRepresentation(UIData.AtomType.optihb,UIData.BondType.optihs);


        }
        GUILayout.EndHorizontal();
        
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
    } // End of SetAtomStyle
        
    
    public static void AtomMenu (int a) {
        LoadTypeGUI.showAtomMenu = LoadTypeGUI.SetTitleExit("Atom appearance");
        SetAtomStyle ();
        RenderingParameters ();
        
        GUILayout.BeginHorizontal();
        LoadTypeGUI.toggle_NA_CLICK = GUILayout.Toggle (LoadTypeGUI.toggle_NA_CLICK, new GUIContent ("Atom selection", "Toggles mouse clicking to select/deselect atoms (left click/right click)"));
        GUILayout.EndHorizontal();
        
        GUILayout.BeginHorizontal();
        LoadTypeGUI.toggle_NA_CAMLOCK = GUILayout.Toggle (LoadTypeGUI.toggle_NA_CAMLOCK, new GUIContent ("Lock camera", "Enable/Disable camera movements"));
        LoadTypeGUI.toggle_LIGHTCAM = GUILayout.Toggle (LoadTypeGUI.toggle_LIGHTCAM, new GUIContent ("Lock light", "Enable/Disable light movements"));

        if(GUI.changed && LoadTypeGUI.toggle_LIGHTCAM != UIData.lightStop){
            LoadTypeGUI.LightStop();
        }
        GUILayout.EndHorizontal();
        
        if (!LoadTypeGUI.toggle_NA_CLICK && LoadTypeGUI.mainCamera.GetComponent<ClickAtom> ())
            LoadTypeGUI.mainCamera.GetComponent<ClickAtom> ().enabled = false;
        else if (LoadTypeGUI.toggle_NA_CLICK && LoadTypeGUI.mainCamera.GetComponent<ClickAtom> ())
            LoadTypeGUI.mainCamera.GetComponent<ClickAtom> ().enabled = true;
        
        
        int sliderWidth = (int) (Rectangles.atomMenuWidth * 0.5f);
        int labelWidth = (int) (Rectangles.atomButtonWidth * 0.4f);
        
        GUILayout.BeginHorizontal();
        HBallManager.brightness = LoadTypeGUI.LabelSlider(HBallManager.brightness, 0.33f, 2.0f, "Brightness: " + HBallManager.brightness.ToString("0.00"), 
                                "Adjusts the brightness of atoms and bonds represented with the MatCap shader",
                                (UIData.atomtype == UIData.AtomType.hyperball||UIData.atomtype == UIData.AtomType.optihb), sliderWidth, labelWidth, false);

        HBallMeshManager.brightness = HBallManager.brightness;

        if(GUI.changed){
            HBallMeshManager.resetBrightness = true;
            HBallManager.resetBrightness = true;
        }
        GUILayout.EndHorizontal();


        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
        GUI.DragWindow();
    } // End of AtomMenu        
    
    



}