SurfaceOldGUI.cs

Go to the documentation of this file.

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

public class SurfaceOldGUI {
    /* 
     * Old GUI related booleans
     */
    public static bool showSurfaceMenu = false;
    public static bool showBfactorMenu = false;
    public static bool showSurfaceTexture = false;
    public static bool showHydroMenu = false;

    // variable for the surface and field lines cutting
    public static bool showSurfaceCut = false;
    public static bool showSurfaceMobileCut = false;

    public static bool cutPlaneIsDraggable = true;
    private static ColorObject tmpSurfaceColor = new ColorObject(Color.white);
    private static ColorObject tmpSurfaceInsideColor = new ColorObject(Color.gray);
    private static bool isTransparentSurface = false;

    private static float alphaTransparentSurface = 0.25f;

    /*****************************
     * Old GUI related functions *
     *****************************/
    
    public static void openCloseSurfaceMenu ()
    {
        if (SurfaceOldGUI.showSurfaceMenu) {
            SurfaceOldGUI.showSurfaceMenu = false;
            //                  showSurfaceCut=false;
            //                  showSurfaceMobileCut=false;
            SurfaceOldGUI.showSurfaceTexture = false;
        } else {
            SurfaceOldGUI.showSurfaceMenu = true;
            SurfaceOldGUI.showBfactorMenu = false;
            LoadTypeGUI.showOpenMenu = false;
            LoadTypeGUI.showReactionMenu = false;
            LoadTypeGUI.showAnimationMenu = false;
        }
        if (!UIData.toggleSurf) {
            UIData.toggleBfac = false;
            UIData.toggleSurf = true;
            SurfaceManager.pdbGen = false;
        }
    }

    public static void Surface (int a) {
        SurfaceOldGUI.showSurfaceMenu = LoadTypeGUI.SetTitleExit("Surface");
        
        GUILayout.BeginHorizontal ();
        SurfaceManager.surfaceThreshold = GUIMoleculeController.LabelSlider (SurfaceManager.surfaceThreshold, 0.002f, 4f, "T:" + Mathf.Round (SurfaceManager.surfaceThreshold * 10f) / 10f,
                                         "Determines ramp value for surface generation", true, (int) (0.5 * Rectangles.surfaceMenuWidth), 1);
        GUILayout.EndHorizontal ();
        
        GUILayout.BeginHorizontal ();
        GUI.enabled = UIData.hasMoleculeDisplay; // trying to generate a surface without a molecule would generate an error
        if (GUILayout.Button (new GUIContent ("Generate", "Generate a new surface mesh"))) {
            SurfaceManager.GenerateSurface();
            isTransparentSurface = false;
        }
        GUILayout.EndHorizontal();
        
        GUILayout.BeginHorizontal ();
        GUI.enabled = UIData.hasMoleculeDisplay; // trying to generate a surface without a molecule would generate an error
        if (GUILayout.Button (new GUIContent ("BFactor", "Generate a new surface mesh using b-factors"))) {
            SurfaceManager.GenerateSurfaceBfact();
        }
        GUILayout.EndHorizontal();
        
        GUILayout.BeginHorizontal ();
        if (GUILayout.Button (new GUIContent("Volumetric", "Display volumetric density"))) {
            SurfaceManager.ShowHideVolumetricDensity();
        }
        GUI.enabled = true;
        GUILayout.EndHorizontal ();
        
        GUILayout.BeginHorizontal();
        GUI.enabled = (UnityMolMain.getSurfaceManager().getSurfaces().Length>0 || MoleculeModel.surfaceFileExists);         
        if (GUILayout.Button (new GUIContent ("Toggle surface", "Toggles surface from visible to hidden and vice versa"))) {
            SurfaceManager.ShowHideSurfaces();
        }   
        GUILayout.EndHorizontal();
        
        
        GUILayout.BeginHorizontal();
        GUI.enabled = true; // otherwise the window might not be draggabl
        
        SurfaceManager.useHetatmForSurface = UIData.hasMoleculeDisplay && GUILayout.Toggle(SurfaceManager.useHetatmForSurface,
                                                                                          new GUIContent("HetAtoms", "Use Hetero atoms for surface calculation"));
        SurfaceManager.useSugarForSurface = UIData.hasMoleculeDisplay && GUILayout.Toggle(SurfaceManager.useSugarForSurface,
                                                                                         new GUIContent("Sugars", "Use sugar for surface calculation"));
        GUILayout.EndHorizontal();
        
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
        
        GUI.enabled = true; // otherwise the window might not be draggable
        GUI.DragWindow();
    } // End of Surface

    public static void SurfaceParams (int a) {
        LoadTypeGUI.SetTitle("Parameters");

        if (GUILayout.Button (new GUIContent ("Transparent", "Show a transparent surface"))){
            // LoadTypeGUI.CreateColorPicker(tmpSurfaceColor,"", null);
            isTransparentSurface = !isTransparentSurface;
            UnityMolMain.getSurfaceManager().SetTransparentSurface(isTransparentSurface);
        }
        if(isTransparentSurface){
            if (GUILayout.Button (new GUIContent ("Color", "Choose the color of the surface"))){
                LoadTypeGUI.CreateColorPicker(tmpSurfaceColor,"Surface Color", null);
            }
            if(LoadTypeGUI.m_colorPicker != null && LoadTypeGUI.m_colorPicker.changed)
            {
                Color mycol = tmpSurfaceColor.color;
                mycol.a = (float)alphaTransparentSurface;
                UnityMolMain.getSurfaceManager().SetTransparentSurfaceColor(mycol);
            }

            float tmpalpha = alphaTransparentSurface;
            tmpalpha = GUIMoleculeController.LabelSlider (tmpalpha, 0f, 1f, "Alpha: " + tmpalpha,
                                         "Determines the transparency of the surface", true, (int) (0.5f * Rectangles.surfaceMenuWidth), 1);

            if(tmpalpha != alphaTransparentSurface){
                alphaTransparentSurface = tmpalpha;
                Color mycol = tmpSurfaceColor.color;
                mycol.a = (float)alphaTransparentSurface;
                UnityMolMain.getSurfaceManager().SetTransparentSurfaceColor(mycol);
            }

        }

        if(!isTransparentSurface){
            if (GUILayout.Button (new GUIContent ("Color", "Choose the color of the surface"))){
                LoadTypeGUI.CreateColorPicker(tmpSurfaceColor,"Surface Color", null);
            }
            if(LoadTypeGUI.m_colorPicker != null && LoadTypeGUI.m_colorPicker.changed)
            {
                SurfaceManager.SurfaceColor = tmpSurfaceColor;
                UnityMolMain.getSurfaceManager().updateColors();
            }
            if (GUILayout.Button (new GUIContent ("Inside color", "Choose the color of the inside of the surface")))
                LoadTypeGUI.CreateColorPicker(tmpSurfaceInsideColor, "Surface inside color", null);

            if(LoadTypeGUI.m_colorPicker != null && LoadTypeGUI.m_colorPicker.changed){
                SurfaceManager.SurfaceInsideColor.color = tmpSurfaceInsideColor.color;
                UnityMolMain.getSurfaceManager().updateColors();
            }

            if(LoadTypeGUI.toggle_NA_HIDE)
                GUI.enabled = false;
            if (GUILayout.Button (new GUIContent ("Use atom color", "Enable/Disable the colors of the atoms on the surface (\"Hide\" must be off)"))) {
                SurfaceManager.SurfaceRenderUp();
            }
            GUI.enabled = true;
            
            if (GUILayout.Button (new GUIContent ("Use chain color", "Enable/Disable the colors of the chain on the surface (\"Hide\" must be off)"))) {
                SurfaceManager.useChainColor();
            }
            
            if (GUILayout.Button (new GUIContent ("Hydrophobic scale", "Open Hydrophobic scales Menu"))) {
                SurfaceOldGUI.showHydroMenu = !SurfaceOldGUI.showHydroMenu;
                
            }
            
            if (GUILayout.Button (new GUIContent ("Use properties color", "Show amino acids properties (red/acid ; blue/basic ; green/polar ; white/apolar) (\"Hide\" must be off)"))) {
                SurfaceManager.usePropertiesColor();
            }
            
            if (GUILayout.Button (new GUIContent ("Use BFactor color", "Show B-Factor values (\"Hide\" must be off)"))) {
                SurfaceManager.useBFactorColor();
            }
            
            
            if (GUILayout.Button (new GUIContent ("Texture", "Choose the texture of the surface"))) 
                SurfaceOldGUI.showSurfaceTexture = !SurfaceOldGUI.showSurfaceTexture;
            
            if (GUILayout.Button (new GUIContent ("Static cut", "Activate a static cut plane on the surface"))) {
                if(SurfaceManager.cutMode == 1){
                    SurfaceManager.cutMode = 0;
                    showSurfaceCut = false;

                }
                else{
                    SurfaceManager.cutMode = 1;
                    showSurfaceCut = true;
                    showSurfaceMobileCut = false;
                }
            }
            
            if (GUILayout.Button (new GUIContent ("Mobile cut", "Activate a mobile cut plane on the surface"))) {
                if(SurfaceManager.cutMode == 2){
                    SurfaceManager.cutMode = 0;
                    showSurfaceMobileCut = false;
                }
                else{
                    SurfaceManager.cutMode = 2;
                    showSurfaceMobileCut = true;
                    showSurfaceCut = false;
                }
            }
            
            GUILayout.BeginHorizontal();
            GUILayout.Label("Brightness: " + SurfaceManager.brightness.ToString("0.00"));
            GUILayout.EndHorizontal();
            
            GUILayout.BeginHorizontal();
            int sliderWidth = (int) (Rectangles.surfaceMenuWidth * 0.9f);
            float brightness = LoadTypeGUI.LabelSlider(SurfaceManager.brightness, 0.33f, 2.0f, "",
                                                    "Adjust the brightness of the surface", true, sliderWidth, 0, false);
            if(GUI.changed)
                SurfaceManager.setBrightness(brightness);
            GUILayout.EndHorizontal();
            
            
            GUILayout.BeginHorizontal();
            GUILayout.Label("Color weight: " + SurfaceManager.colorWeight.ToString("0.00"));
            GUILayout.EndHorizontal();
            
            GUILayout.BeginHorizontal();
            float colorWeight = LoadTypeGUI.LabelSlider(SurfaceManager.colorWeight, 0f, 1f, "",
                                                     "Adjust the weight of the vertex colors of the surface", true, sliderWidth, 0, false);
            if(GUI.changed)
                SurfaceManager.setColorWeight(colorWeight);     
            GUILayout.EndHorizontal();
        }
        
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
        
        GUI.DragWindow();
    } // End of Surface Params

    public static void HydroMenu (int a) {
        
        SurfaceOldGUI.showHydroMenu = LoadTypeGUI.SetTitleExit("Hydrophobic scales");
        
        if (GUILayout.Button (new GUIContent ("Kyte & Doolittle", "Surface coloring by using Kyte and Doolittle hydrophobic scale"))) {
            SurfaceManager.useKyteAndDoolittleColor();
        }
        
        if (GUILayout.Button (new GUIContent ("Engleman & al.", "Surface coloring by using Engleman & al hydrophobic scale"))) {
            SurfaceManager.useEnglemanColor();
        }
        
        if (GUILayout.Button (new GUIContent ("Eisenberg", "Surface coloring by using Eisenberg scale"))) {
            SurfaceManager.useEinsenbergColor();
        }
        
        if (GUILayout.Button (new GUIContent ("White Octanol", "Surface coloring by using White Octanol scale"))) {
            SurfaceManager.useWhiteOctanolColor();
        }
        
        GUI.DragWindow();
        
    } // End of HydroMenu

    public static void SurfaceCut (int a) {
        SurfaceOldGUI.showSurfaceCut = LoadTypeGUI.SetTitleExit("Cut Parameters");

        int sliderWidth = (int) (Rectangles.surfaceCutWidth * 0.80f);
        
        SurfaceManager.depthCut = LoadTypeGUI.LabelSlider (SurfaceManager.depthCut, SurfaceManager.depthCutMin, SurfaceManager.depthCutMax, "Depth " + SurfaceManager.depthCut.ToString("0.00"), 
                                              "Determines cut plane depth position", true, sliderWidth, 1, true); 
        SurfaceManager.cutX = LoadTypeGUI.LabelSlider (SurfaceManager.cutX, -1f, 1f, " X: " + SurfaceManager.cutX.ToString("0.00"),
                                          "Determines cut plane X position", true, sliderWidth, 1, true); 
        SurfaceManager.cutY = LoadTypeGUI.LabelSlider (SurfaceManager.cutY, -1f, 1f, " Y: " + SurfaceManager.cutY.ToString("0.00"),
                                          "Determines cut plane Y position", true, sliderWidth, 1, true); 
        SurfaceManager.cutZ = LoadTypeGUI.LabelSlider (SurfaceManager.cutZ, -1f, 1f, " Z: " + SurfaceManager.cutZ.ToString("0.00"),
                                          "Determines cut plane Z position", true, sliderWidth, 1, true);
        
        if(GUI.changed)
            UnityMolMain.getSurfaceManager().updateCut();
        GUI.enabled = true;
        GUI.DragWindow();
    }

    public static void MoveCutPlane (int a) {
        LoadTypeGUI.SetTitle("Move cut plane");
        if(SurfaceOldGUI.cutPlaneIsDraggable)
            GUI.DragWindow();
        
        Vector3 mousePos = Input.mousePosition;
        mousePos.y = Screen.height - mousePos.y;
        if (Rectangles.movePlaneRect.Contains(mousePos) && SurfaceOldGUI.showSurfaceCut && SurfaceOldGUI.showSurfaceMenu 
            && !LoadTypeGUI.InDeadZone(Rectangles.movePlaneRect, mousePos) && GUIUtility.hotControl == 0) 
        {
            if (Input.GetMouseButton (0)) {
                SurfaceManager.cutX += Input.GetAxis ("Mouse X") * 1 * 0.02f;
                SurfaceManager.cutY -= Input.GetAxis ("Mouse Y") * 1 * 0.02f;
                SurfaceManager.cutZ -= Input.GetAxis ("Mouse X") * 1 * 0.02f;
            }
            if (SurfaceManager.cutX < -1)
                SurfaceManager.cutX = -1;
            if (SurfaceManager.cutX > 1)
                SurfaceManager.cutX = 1;
            if (SurfaceManager.cutY < -1)
                SurfaceManager.cutY = -1;
            if (SurfaceManager.cutY > 1)
                SurfaceManager.cutY = 1;
            if (SurfaceManager.cutZ < -1)
                SurfaceManager.cutZ = -1;
            if (SurfaceManager.cutZ > 1)
                SurfaceManager.cutZ = 1;
            SurfaceManager.depthCut -= Input.GetAxis ("Mouse ScrollWheel");
            UnityMolMain.getSurfaceManager().updateCut();
        }
    }

    public static void SurfaceMobileCut (int a) {
        int sliderWidth = (int) (Rectangles.surfaceCutWidth * 0.45f);
        LoadTypeGUI.SetTitle("Surface Mobile Cut");
        SurfaceManager.depthCut = LoadTypeGUI.LabelSlider (SurfaceManager.depthCut, -40f, 40f, "Cutting depth " + SurfaceManager.depthCut,
                                              "Determines mobile cut plane depth position", true, sliderWidth, 1); 

        UnityMolMain.getElectrostaticManager().adjustFieldLineCut = LoadTypeGUI.LabelSlider (UnityMolMain.getElectrostaticManager().adjustFieldLineCut, -100f, 100f, " FL cut :" + UnityMolMain.getElectrostaticManager().adjustFieldLineCut,
                                                        "Determines field line cut position", true, sliderWidth, 1); 

        if(UnityMolMain.getElectrostaticManager().nbFieldLine() == 0)
            GUI.enabled = false;

        if(GUI.changed)
            UnityMolMain.getSurfaceManager().updateCut();
        GUI.DragWindow();
    }


        
    private static void textureMenu (string texDir, string[] texList, string texDescr) {
    //          GUI.Label (new Rect (0, 0, 290, 20), "Surface Texture - " + texDescr, CentredText);
        SurfaceOldGUI.showSurfaceTexture = LoadTypeGUI.SetTitleExit("Surface Texture - " + texDescr); //, CentredText);
        
        #if !UNITY_WEBPLAYER
        SurfaceManager.m_last_extSurf_Path = System.IO.Directory.GetCurrentDirectory();
        #endif

        GUILayout.BeginHorizontal();
        GUILayout.FlexibleSpace();
        UIData.grayscalemode = GUILayout.Toggle (UIData.grayscalemode, new GUIContent ("Grayscale", "Use grayscale version of the texture"));
        GUILayout.EndHorizontal();
        
        GUILayout.BeginHorizontal ();
        if (GUILayout.Button (new GUIContent ("<<", "Go to previous series of textures"))) { // cycle through texture sets 
            LoadTypeGUI.texture_set--; 
                
            if(LoadTypeGUI.onlyBestTextures){
                if(LoadTypeGUI.texture_set < 0)
                    LoadTypeGUI.texture_set = 4; // First 5 pages are best textures (0-4)
            }
            else{
                if(LoadTypeGUI.texture_set < 5)
                    LoadTypeGUI.texture_set = GUIDisplay.textureMenuList.Count - 1;
            }
        }           

    //          if(GUILayout.Button(new GUIContent("Confirm","Confirm all the modification of the molecule.")))
        if (GUILayout.Button (new GUIContent ("Open", "Open custom texture image from disk"))) {    
            LoadTypeGUI.FileBrowser_show2 = true;
            LoadTypeGUI.m_fileBrowser = new ImprovedFileBrowser (
                new Rect (400, 100, 600, 500),
                "Choose Image File",
                FileSelectedCallback,
                SurfaceManager.m_last_extSurf_Path
            );
        }
        
        if (GUILayout.Button (new GUIContent (">>", "Go to next series of textures"))) { // cycle through texture sets 
            LoadTypeGUI.texture_set++; 

            if (LoadTypeGUI.onlyBestTextures) {
                if(LoadTypeGUI.texture_set>4) // First 5 pages are best textures (0-4)
                    LoadTypeGUI.texture_set = 0;
            }
            else{
                if (LoadTypeGUI.texture_set > GUIDisplay.textureMenuList.Count - 1)
                    LoadTypeGUI.texture_set = 5;
            }
        }           
        GUILayout.EndHorizontal ();
        
        GUILayout.BeginHorizontal ();           

        // check whether texList has more than 15 entries and raise an error!!
        int i = 0;
    //          GUILayout.EndHorizontal(); GUILayout.Box(texDescr); GUILayout.BeginHorizontal();
        foreach (string texFil in texList) {
            i++; 
            if (i > 5) {
                GUILayout.EndHorizontal (); 
                GUILayout.BeginHorizontal (); 
                i = 1;
            }
    //              if(GUILayout.Button((Texture2D)Resources.Load(texDir+texFil),GUILayout.Width(50),GUILayout.Height(50))) 
            int buttonWidth = (int) (Rectangles.textureWidth *0.18f);
            int buttonHeight = (int) (Rectangles.textureHeight / 4f);
            if (GUILayout.Button (new GUIContent ((Texture2D)Resources.Load (texDir + texFil), texFil), GUILayout.Width (buttonWidth), GUILayout.Height (buttonHeight))) { 
                if(texFil != "None") {
                    SurfaceManager.surfaceTextureName = texDir + texFil;
                    UnityMolMain.getSurfaceManager().updateTexture();
                }
                else {
                    SurfaceManager.surfaceTextureName = "lit_spheres/divers/daphz1";
                    UnityMolMain.getSurfaceManager().updateTexture();
                }
            }   
        }
        GUILayout.EndHorizontal ();
        if (Event.current.type == EventType.Repaint)
            MoleculeModel.newtooltip = GUI.tooltip;
    }


    public static void SurfaceTexture (int a) {
        
        textureMenu ("lit_spheres/", GUIDisplay.textureMenuList[LoadTypeGUI.texture_set], GUIDisplay.textureMenuTitles[LoadTypeGUI.texture_set]);
        
        GUI.DragWindow();
    }   // End of SurfaceTexture                

    public static void FileSelectedCallback (string path) {
        #if !UNITY_WEBPLAYER
        GUIMoleculeController.m_fileBrowser = null;
        if (path != null) {
            GUIMoleculeController.m_textPath = path;
            SurfaceManager.m_last_extSurf_Path = System.IO.Path.GetDirectoryName (path);
            SurfaceManager.externalSurfaceTexture = true;
        }
        //              FileBrowser_show = false;
        GUIMoleculeController.FileBrowser_show2 = false;
        WWW www = new WWW ("file://" + GUIMoleculeController.m_textPath);
        SurfaceManager.extSurf = www.texture;
        Debug.Log (GUIMoleculeController.m_textPath);
        #endif
    }
}