~repos /gdx-studio

package gdxstudio.panel;

import gdxstudio.Content;
import gdxstudio.Frame;
import gdxstudio.GdxStudio;
import gdxstudio.Style;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Insets;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetDropEvent;
import java.io.File;
import java.nio.ByteBuffer;

import javax.swing.JPanel;
import javax.swing.JScrollPane;

import org.lwjgl.LWJGLException;
import org.lwjgl.opengl.GLContext;

import scene2d.Asset;
import scene2d.Effect;
import scene2d.EffectType;
import scene2d.ImageJson;
import scene2d.InterpolationType;
import scene2d.Map;
import scene2d.Scene;
import scene2d.Sprite;
import web.laf.lite.layout.HorizontalFlowLayout;
import web.laf.lite.layout.VerticalFlowLayout;
import web.laf.lite.utils.UIUtils;
import web.laf.lite.widget.CenterPanel;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.backends.lwjgl.LwjglAWTCanvas;
import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
import com.badlogic.gdx.backends.lwjgl.LwjglCanvas;
import com.badlogic.gdx.files.FileHandle;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Pixmap;
import com.badlogic.gdx.graphics.Pixmap.Format;
import com.badlogic.gdx.graphics.PixmapIO;
import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.ui.Button;
import com.badlogic.gdx.scenes.scene2d.ui.CheckBox;
import com.badlogic.gdx.scenes.scene2d.ui.Dialog;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.scenes.scene2d.ui.Label.LabelStyle;
import com.badlogic.gdx.scenes.scene2d.ui.List;
import com.badlogic.gdx.scenes.scene2d.ui.SelectBox;
import com.badlogic.gdx.scenes.scene2d.ui.Slider;
import com.badlogic.gdx.scenes.scene2d.ui.Table;
import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
import com.badlogic.gdx.scenes.scene2d.ui.TextField;
import com.badlogic.gdx.scenes.scene2d.ui.Touchpad;
import com.badlogic.gdx.tools.hiero.HieroPanel;
import com.badlogic.gdx.tools.particleeditor.ParticlePanel;
import com.badlogic.gdx.tools.particleeditor.ParticleRenderer;
import com.badlogic.gdx.utils.Timer.Task;


final public class StudioPanel extends JPanel  {
  private static final long serialVersionUID = 1L;
  LwjglCanvas can;
  public LwjglAWTCanvas canvas;
  JPanel hbox;
  CenterPanel centerPanel;
  JScrollPane scrollPane;
  LwjglApplicationConfiguration config2 = new LwjglApplicationConfiguration();

  Image img;
  public StudioPanel(){
    super(new VerticalFlowLayout());
    hbox = new JPanel(new HorizontalFlowLayout());
    hbox.add(new HeaderLabel("Screen Size"));
    hbox.add(new HeaderLabel("Target Size"));
    UIUtils.setMargin(this, new Insets(15,15,15,15));
    config2.width = 640;
    config2.height = 320;
    config2.fullscreen = false;
    config2.useGL20 = false;
  }



  @Override
  public void paint(Graphics g){
    if(!isOpaque())
      Style.drawScreen(g, getWidth(), getHeight());
    super.paint(g);

  }

  String config = "{"
    +"title: GdxStudio,"
    +"keepAspectRatio: false,"
    +"showFPS: false,"
    +"loggingEnabled: true,"
    +"}";

  public void createHieroCanvas(){
    setOpaque(true);
    removeAll();
    HieroPanel panel = new HieroPanel();
    canvas = new  LwjglAWTCanvas(new HieroPanel.FontRenderer() , false);
    HieroPanel.gamePanel.add(canvas.getCanvas());
    JScrollPane scrollPane = new JScrollPane(panel);
    scrollPane.setPreferredSize(new Dimension(860, 650));
    UIUtils.setDrawBorder(scrollPane, false);
    add(scrollPane);
  }

  public void createParticleCanvas(){
    setOpaque(true);
    removeAll();
    ParticlePanel panel = new ParticlePanel();
    canvas = new  LwjglAWTCanvas(new ParticleRenderer(panel) , false);
    panel.initializeComponents(canvas);
    JScrollPane scrollPane = new JScrollPane(panel);
    scrollPane.setPreferredSize(new Dimension(860, 650));
    UIUtils.setDrawBorder(scrollPane, false);
    add(scrollPane);
  }

  public void createStudioCanvas(){
    removeAll();
    GdxStudio.log("Creating Studio Canvas");
    try{
      Scene.configJson = Scene.jsonReader.parse(config);
      Scene.debug = true;
      Scene.scenesMap.clear();
      Scene.scenesMap.put("gdxstudio.SceneEditor", "");
      setOpaque(false);
      canvas = new  LwjglAWTCanvas(Scene.app , false);
      scrollPane = new JScrollPane(canvas.getCanvas());
      scrollPane.setPreferredSize(new Dimension(800, 480));
      UIUtils.setDrawBorder(scrollPane, false);
      Style.setScreenSize(scrollPane.getPreferredSize().width, scrollPane.getPreferredSize().height);
      centerPanel = new CenterPanel(scrollPane, true, false);
      centerPanel.setBackground(Color.black);
      UIUtils.setUndecorated(centerPanel, true);
      UIUtils.setMargin(centerPanel, new Insets(0,0,0,0));
      add(centerPanel);
      validate();
      Style.setScreenPosition(scrollPane.getLocation().x, scrollPane.getLocation().y);
      canvas.getCanvas().setDropTarget(new DropTarget() {
        private static final long serialVersionUID = 1L;
        public synchronized void drop(DropTargetDropEvent event) {
          try{
            Transferable transferable = event.getTransferable();
            if( transferable.isDataFlavorSupported(DataFlavor.stringFlavor )){
              event.acceptDrop( DnDConstants.ACTION_MOVE );
              String s = (String)transferable.getTransferData(DataFlavor.stringFlavor);
              createActor(s);
              event.getDropTargetContext().dropComplete(true);
            }
            else{
              event.rejectDrop();
            }
          }
          catch( Exception exception ){
            System.err.println( "Exception" + exception.getMessage() );
            event.rejectDrop();
          }
        }
      });
      Asset.save();
    }catch(Exception ex){
      ex.printStackTrace();
    }
  }

  public void setGdxScreenSize(int width, int height){
    removeAll();
    canvas.getCanvas().setSize(width, height);
    scrollPane = new JScrollPane(canvas.getCanvas());
    scrollPane.setPreferredSize(new Dimension(width, height));
    UIUtils.setDrawBorder(scrollPane, false);
    Style.setScreenSize(scrollPane.getPreferredSize().width, scrollPane.getPreferredSize().height);
    scrollPane.setPreferredSize(new Dimension(width, height));
    centerPanel = new CenterPanel(scrollPane, true, false);
    centerPanel.setBackground(Color.black);
    UIUtils.setUndecorated(centerPanel, true);
    UIUtils.setMargin(centerPanel, new Insets(0,0,0,0));
    add(centerPanel);
    validate();
    Style.setScreenPosition(scrollPane.getLocation().x, scrollPane.getLocation().y);
    canvas.makeCurrent();
        try {
      GLContext.useContext(canvas);
    } catch (LWJGLException e) {
      e.printStackTrace();
    }
  }

  public void revalidateScreenPosition(){
    if(scrollPane != null){
      validate();
      Style.setScreenPosition(canvas.getCanvas().getLocation().x, canvas.getCanvas().getLocation().y);
    }
  }

  public void destroyCanvas(){
    GdxStudio.log("Destroying Scene Canvas");
    if(canvas != null){
      remove(canvas.getCanvas());
      canvas.stop();
      canvas = null;
    }
  }

  private int getNameCount(Actor actor){
    int count = 1;
    for(Actor child: Scene.getCurrentScene().getChildren())
      if(actor.getClass().equals(child.getClass())) count++;
    return count;
  }


  public void setName(final Actor actor){
    com.badlogic.gdx.utils.Timer.schedule(new Task(){
      @Override
      public void run() {
        String name = actor.getClass().getSimpleName()+getNameCount(actor);
        if(Scene.getCurrentScene().findActor(name) == null)
          actor.setName(name);
        else
          actor.setName(name+"_1");
        actor.setX(Scene.mouse.x-actor.getWidth()/2);
        actor.setY(Scene.mouse.y-actor.getHeight()/2);
        Scene.getCurrentScene().addActor(actor);
        Frame.actorPanel.addActor(actor.getName());
        Scene.isDirty = true;
        Effect.createEffect(actor, EffectType.ScaleInOut, 1.5f, 0.5f, InterpolationType.Linear);
      }
    }, 0.1f);
  }

  public void createActor(String type){
    switch(type){
      case "Label":
        if(Asset.fontMap.size != 0){
          LabelStyle ls = new LabelStyle();
          ls.font = Asset.fontMap.firstValue();
          Label label = new Label("Text", ls);
          setName(label);
        }
        break;
      case "Image":
        if(Asset.texMap.size != 0){
          setName(new ImageJson(Asset.texMap.firstKey()));
        }
        break;
      case "Texture":setName(new ImageJson(Content.assetPanel.list.getSelectedValue()));break;
      case "Sprite":setName(new Sprite(1f, Asset.texMap.firstKey()));break;
      case "Particle":
        //ParticleEffect pe = new ParticleEffect();
        //pe.load(effectFile, imagesDir);
        break;

      case "Button":setName(new Button(Asset.skin));break;
      case "TextButton":setName(new TextButton("Text", Asset.skin));break;
      case "TextField":setName(new TextField("", Asset.skin));break;
      case "Table":setName(new Table(Asset.skin));break;
      case "CheckBox":setName(new CheckBox("Check", Asset.skin));break;
      case "SelectBox":setName(new SelectBox(new String[]{"First","Second","Third"}, Asset.skin));break;
      case "List":setName(new List(new String[]{"First","Second","Third"}, Asset.skin));break;
      case "Slider":setName(new Slider(0, 10, 1, false, Asset.skin));break;
      case "Dialog":setName(new Dialog("Title", Asset.skin));break;
      case "Touchpad":setName(new Touchpad(5, Asset.skin));break;
      case "Map":setName(new Map(1, 24));break;
      case "None":break;
      default:break;
    }
  }

  public static void updateAssets(){
    StringBuilder sb = new StringBuilder();
    for(String filename: new File(Asset.basePath+"font").list()){
      if(filename.endsWith(".fnt")){
        GdxStudio.log("Loading :"+filename);
        sb.append(filename);
        sb.append(",");
      }
    }
    Asset.assetMap.put("font", sb.toString());
    sb = new StringBuilder();
    for(String filename: new File(Asset.basePath+"atlas").list()){
      if(filename.endsWith(".atlas")){
        GdxStudio.log("Loading :"+filename);
        sb.append(filename);
        sb.append(",");
      }
    }
    Asset.assetMap.put("atlas", sb.toString());
    sb = new StringBuilder();
    for(String filename: new File(Asset.basePath+"sound").list()){
      if(filename.endsWith(".mp3")){
        GdxStudio.log("Loading :"+filename);
        sb.append(filename);
        sb.append(",");
      }
    }
    Asset.assetMap.put("sound", sb.toString());
    sb = new StringBuilder();
    for(String filename: new File(Asset.basePath+"music").list()){
      if(filename.endsWith(".mp3")){
        GdxStudio.log("Loading :"+filename);
        sb.append(filename);
        sb.append(",");
      }
    }
    Asset.assetMap.put("music", sb.toString());
    sb = new StringBuilder();
    for(String filename: new File(Asset.basePath+"model").list()){
      if(filename.endsWith(".obj") || filename.endsWith(".g3db")){
        GdxStudio.log("Loading :"+filename);
        Asset.modelMap.add(filename);
      }
    }
  }

  private static int counter = 1;
    public static void saveScreenshot(){
        try{
            FileHandle fh;
            do{
                fh = new FileHandle("shots/shot" + counter++ + ".png");
            }while (fh.exists());
            Pixmap pixmap = getScreenshot(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), false);
            PixmapIO.writePNG(fh, pixmap);
            pixmap.dispose();
        }catch (Exception e){
        }
    }

    private static Pixmap getScreenshot(int x, int y, int w, int h, boolean flipY){
        Gdx.gl.glPixelStorei(GL20.GL_PACK_ALIGNMENT, 1);

        final Pixmap pixmap = new Pixmap(w, h, Format.RGBA8888);
        ByteBuffer pixels = pixmap.getPixels();
        Gdx.gl.glReadPixels(x, y, w, h, GL20.GL_RGBA, GL20.GL_UNSIGNED_BYTE, pixels);

        final int numBytes = w * h * 4;
        byte[] lines = new byte[numBytes];
        if (flipY){
            pixels.clear();
            pixels.get(lines);
        }else{
            final int numBytesPerLine = w * 4;
            for (int i = 0; i < h; i++){
                pixels.position((h - i - 1) * numBytesPerLine);
                pixels.get(lines, i * numBytesPerLine, numBytesPerLine);
            }
            pixels.clear();
            pixels.put(lines);
        }
        return pixmap;
    }
}