Copied JOGL_2_SANDBOX r350 on to trunk; JOGL_2_SANDBOX branch is now closed

git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/../svn-server-sync/jogl-demos/trunk@352 3298f667-5e0e-4b4a-8ed4-a3559d26a5f4

1 files changed, 1065 insertions, 0 deletions

diff --git a/src/demos/nurbs/surfaceapp/SurfaceApp.java b/src/demos/nurbs/surfaceapp/SurfaceApp.java
new file mode 100755
index 0000000..4018967
--- /dev/null
+++ b/src/demos/nurbs/surfaceapp/SurfaceApp.java
@@ -0,0 +1,1065 @@
+package demos.nurbs.surfaceapp;
+
+import java.awt.Dimension;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.AbstractAction;
+import javax.swing.ButtonGroup;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JSeparator;
+import javax.swing.JSlider;
+import javax.swing.JSpinner;
+import javax.swing.JToggleButton;
+import javax.swing.JToolBar;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.ToolTipManager;
+
+import demos.nurbs.icons.*;
+import demos.nurbs.knotslidercomponent.JKnotSlider;
+import javax.media.opengl.awt.GLCanvas;
+
+/**
+ * Main class for application demostrating capabilitues of JOGL library extend by NURBS surface functionalities
+ * Hlavní třída aplikace demonstrující shopnosti knihovny JOGL při práci s NURBS
+ * plochami
+ * 
+ * @author Tomáš Hráský
+ * 
+ */
+@SuppressWarnings("serial")
+public class SurfaceApp extends JFrame implements ActionListener
+{
+
+    /**
+     * X-coord editing component name
+     * Jméno komponenty pro editaci X-ové souřadnice aktuálního bodu
+     */
+    public static final String X_SPINNER_NAME = "xspinner";
+
+    /**
+     * Y-coord editing component name
+     * Jméno komponenty pro editaci Y-ové souřadnice aktuálního bodu
+     */
+    public static final String Y_SPINNER_NAME = "yspinner";
+
+    /**
+     * Z-coord editing component name
+     * Jméno komponenty pro editaci Z-ové souřadnice aktuálního bodu
+     */
+  public static final String Z_SPINNER_NAME = "zspinner";
+
+  /**
+   * Weight editing component name
+   * Jméno komponenty pro editaci váhy aktuálního bodu
+   */
+  public static final String W_SPINNER_NAME = "wspinner";
+
+  /**
+   * U direction knotvector editing component
+   * Jméno komponenty pro editaci uzlového vektoru ve směru parametru U
+   */
+  private static final String U_KNOTSLIDER = "Uknotspinner";
+
+  /**
+   * V direction knotvector editing component
+   * Jméno komponenty pro editaci uzlového vektoru ve směru parametru V
+   */
+  private static final String V_KNOTSLIDER = "Vknotspinner";
+
+  /**
+   * New control point action name
+   * Jméno události přidání řídícího bodu
+   */
+  public static final String PRIDAT_AC = "PRIDAT";
+
+  /**
+   * Degree set event name
+   * Jméno události zadání stupně křivky
+   */
+  public static final String STUPEN_AC = "STUPEN";
+
+  /**
+   * Delete control point event name
+   * Jméno události smazání řídícího bodu
+   */
+  public static final String SMAZAT_AC = "SMAZAT";
+
+  /**
+   * New clamped knotvector event name
+   * Jméno události vytvoření uzavřeného uzlového vektoru
+   */
+  public static final String UZAVRENY_AC = "UZAVRENY";
+
+  /**
+   * New uniform knotvector event name
+   * Jméno události vytvoření otevřeného (uniformního) uzlového vektoru
+   */
+  public static final String OTEVRENY_AC = "OTEVRENY";
+
+  /**
+   * Save surface event name
+   * Jméno události uložení plochy
+   */
+  public static final String ULOZIT_AC = "ULOZIT";
+
+  /**
+   * Load surface event name
+   * Jméno události načetení uložené definice plochy
+   */
+  public static final String NACIST_AC = "NACIST";
+
+  /**
+   * Move control point event name
+   * Jméno události pohybu řídícího bodu
+   */
+  private static final String MOVE_AC = "MOVE";
+
+  /**
+   * New surface event name
+   * Jméno události vytvoření nové plochy
+   */
+  static final String NOVA_AC = "NEWSURFACE";
+
+  /**
+   * Exit app event name
+   * Jméno události ukončení aplikace
+   */
+  public static final String EXIT_AC = "EXIT";
+
+  /**
+   * Show about event name
+   * Jméno události zobrazení okna o aplikaci
+   */
+  public static final String INFO_AC = "INFO";
+
+  /**
+   * Add column of control points event name
+   * Jméno události přidání sloupce řídících bodů
+   */
+  public static final String PRIDAT_AC_SLOUPEC = "ADDCOL";
+
+  /**
+   * Add row of control points event name
+   * Jméno události přidání řádku řídících bodů
+   */
+  public static final String PRIDAT_AC_RADEK = "ADDROW";
+
+  /**
+   * Remove row of control points event name
+   * Jméno události smazání řádku řídících bodů
+   */
+  public static final String SMAZAT_AC_RADEK = "DELROW";
+
+  /**
+   * Remove column of control points event name
+   * Jméno události smazání sloupce řídících bodů
+   */
+  public static final String SMAZAT_AC_SLOUPEC = "DELCOL";
+
+  /**
+   * OpenGL drawing canvas
+   * Plátno pro vykreslování pomocí OpenGL
+   */
+  private GLCanvas glCanvas;
+
+  /**
+   * X-coord editing component
+   * Komponenta pro editaci X-ové souřadnice aktuálního bodu
+   */
+  private JSpinner xSpinner;
+
+  /**
+   * Y-coord editing component
+   * Komponenta pro editaci Y-ové souřadnice aktuálního bodu
+   */
+  private JSpinner ySpinner;
+
+  /**
+   * Weight editing component
+   * Komponenta pro editaci váhy aktuálního bodu
+   */
+  private JSpinner wSpinner;
+
+  /**
+   * Z-coord editing component
+   * Komponenta pro editaci Z-ové souřadnice aktuálního bodu
+   */
+  private JSpinner zSpinner;
+
+  /**
+   * Mouse listener
+   * Listener událostí myši
+   */
+  private SurfaceMouseListener mouseListener;
+
+  /**
+   * U direction knotvector editing component
+   * Komponenta pro editaci uzlového vektoru ve směru parametru U
+   */
+  private JKnotSlider knotSlider;
+
+  /**
+   * V direction knotvector editing component
+   * Komponenta pro editaci uzlového vektoru ve směru parametru V
+   */
+  private JKnotSlider knotSlider2;
+
+  /**
+   * Set move points mode
+   * Tlačítko pro zapnutí módu pohybu řídících bodů
+   */
+  private JToggleButton moveTB;
+
+  /**
+   * X rotation component
+   * Komponenta ovládající otočení definované plochy kolem osy X
+   */
+  private JSlider rotaceXSlider;
+
+  /**
+   * Y rotation component
+   * Komponenta ovládající otočení definované plochy kolem osy Y
+   */
+  private JSlider rotaceYSlider;
+
+  /**
+   * Z rotation component
+   * Komponenta ovládající otočení definované plochy kolem osy Z
+   */
+  private JSlider rotaceZSlider;
+
+  /**
+   * Label for X rotation editing component
+   * Nadpis komponenty ovládající otočení definované plochy kolem osy X
+   */
+  private JLabel rotaceXLabel;
+  /**
+   * Label for Y rotation editing component
+   * Nadpis komponenty ovládající otočení definované plochy kolem osy Y
+   */
+  private JLabel rotaceYLabel;
+  /**
+   * Label for Z rotation editing component
+   * Nadpis komponenty ovládající otočení definované plochy kolem osy Z
+   */
+  private JLabel rotaceZLabel;
+
+  /**
+   * GL events listener
+   * Objekt reagující na události OpenGL plátna
+   */
+  private GLListener glListener;
+
+  /**
+   * Use lighting checkbox
+   * Checkbox použití nasvícení objektu 
+   */
+  private JCheckBox lightingChBox;
+
+  /**
+   * Constructor, creates GUI
+   * Konstruktor, vytvoří grafické uživatelské rozhraní
+   */
+  public SurfaceApp() {
+    //super( "Tomáš Hráský - ukázková aplikace funkcionality GLU NURBS funkcí - JOGL");
+    super( "Tomáš Hráský - example application of GLU NURBS in JOGL");
+    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+    initGUI();
+  }
+
+  /**
+   * GUI initialization
+   * Inicializace grafického uživatelského rozhraní
+   */
+  private void initGUI() {
+    JPopupMenu.setDefaultLightWeightPopupEnabled(false);
+    ToolTipManager.sharedInstance().setLightWeightPopupEnabled(false);
+
+    this.glCanvas = new GLCanvas();
+    glCanvas.setSize(new Dimension(750, 500));
+    this.glListener=new GLListener(this);
+    glCanvas.addGLEventListener(glListener);
+    mouseListener = new SurfaceMouseListener(this);
+    glCanvas.addMouseListener(mouseListener);
+    glCanvas.addMouseMotionListener(mouseListener);
+    setLayout(new GridBagLayout());
+    GridBagConstraints c = new GridBagConstraints();
+    c.fill = GridBagConstraints.BOTH;
+
+    c.gridy = 0;
+    c.gridwidth = GridBagConstraints.REMAINDER;
+
+    ActListener listener = new ActListener(this);
+
+    JMenuBar menuBar = new JMenuBar();
+    getContentPane().add(menuBar, c);
+
+    JMenu aplikaceMenu = new JMenu("Aplication");
+    menuBar.add(aplikaceMenu);
+
+    JMenuItem aboutMI = new JMenuItem("About");
+    aboutMI.setActionCommand(INFO_AC);
+    aboutMI.addActionListener(listener);
+    aplikaceMenu.add(aboutMI);
+
+    aplikaceMenu.add(new JSeparator());
+
+    JMenuItem konecMI = new JMenuItem("Exit");
+    konecMI.addActionListener(listener);
+    konecMI.setActionCommand(EXIT_AC);
+    aplikaceMenu.add(konecMI);
+
+    JMenu krivkaMenu = new JMenu("Surface");
+    menuBar.add(krivkaMenu);
+
+    JMenu pridatBodyM = new JMenu("Add points");
+    krivkaMenu.add(pridatBodyM);
+    //		pridatBodyM.addActionListener(listener);
+
+    //		pridatBodyM.setActionCommand(PRIDAT_AC);
+		
+    JMenuItem pridatRadkyMI=new JMenuItem("Points row");
+    pridatRadkyMI.setActionCommand(PRIDAT_AC_RADEK);
+    pridatRadkyMI.addActionListener(listener);
+		
+    JMenuItem pridatSloupceMI=new JMenuItem("Points column");
+    pridatSloupceMI.setActionCommand(PRIDAT_AC_SLOUPEC);
+    pridatSloupceMI.addActionListener(listener);
+    pridatBodyM.add(pridatRadkyMI);
+    pridatBodyM.add(pridatSloupceMI);
+		
+		
+    JMenu smazatBodyM = new JMenu("Delete points");
+    krivkaMenu.add(smazatBodyM);
+    //		smazatBodyM.addActionListener(listener);
+
+    //		smazatBodyM.setActionCommand(SMAZAT_AC);
+
+    JMenuItem smazatRadkyMI=new JMenuItem("Points row");
+    smazatRadkyMI.setActionCommand(SMAZAT_AC_RADEK);
+    smazatRadkyMI.addActionListener(listener);
+    smazatBodyM.add(smazatRadkyMI);
+    JMenuItem smazatSloupceMI=new JMenuItem("Points column");
+    smazatSloupceMI.setActionCommand(SMAZAT_AC_SLOUPEC);
+    smazatSloupceMI.addActionListener(listener);
+    smazatBodyM.add(smazatSloupceMI);
+		
+		
+    JMenuItem stupenMI = new JMenuItem("Set surface degree");
+    krivkaMenu.add(stupenMI);
+    stupenMI.addActionListener(listener);
+    stupenMI.setActionCommand(STUPEN_AC);
+
+    JMenu knotVecMenu = new JMenu("Create knotvectors");
+    krivkaMenu.add(knotVecMenu);
+
+    JMenuItem clampedKVMI = new JMenuItem("Clamped");
+    knotVecMenu.add(clampedKVMI);
+    clampedKVMI.setActionCommand(UZAVRENY_AC);
+    clampedKVMI.addActionListener(listener);
+    JMenuItem unclampedKVMI = new JMenuItem("Uniform");
+    knotVecMenu.add(unclampedKVMI);
+    unclampedKVMI.setActionCommand(OTEVRENY_AC);
+    unclampedKVMI.addActionListener(listener);
+
+    JMenuItem moveMI = new JMenuItem("Move points");
+    krivkaMenu.add(moveMI);
+    moveMI.setActionCommand(MOVE_AC);
+    moveMI.addActionListener(listener);
+
+    krivkaMenu.add(new JSeparator());
+
+    krivkaMenu.add(new JSeparator());
+
+    JMenuItem novaMI = new JMenuItem("New surface");
+    krivkaMenu.add(novaMI);
+    novaMI.setActionCommand(NOVA_AC);
+    novaMI.addActionListener(listener);
+
+    JMenuItem ulozitMI = new JMenuItem("Safe surface as...");
+    krivkaMenu.add(ulozitMI);
+    ulozitMI.setActionCommand(ULOZIT_AC);
+    ulozitMI.addActionListener(listener);
+    JMenuItem nacistMI = new JMenuItem("Load surface");
+    krivkaMenu.add(nacistMI);
+    nacistMI.setActionCommand(NACIST_AC);
+    nacistMI.addActionListener(listener);
+
+    c.gridy++;
+    JToolBar toolBar = new JToolBar();
+    getContentPane().add(toolBar, c);
+
+    ButtonGroup bg = new ButtonGroup();
+
+    JButton novaB = new JButton();
+    // novaB.setText("Nová");
+    novaB.setToolTipText("New surface");
+    novaB.setIcon(IconFactory.getIcon("demos/nurbs/icons/folder_new.png"));
+    novaB.setActionCommand(NOVA_AC);
+    novaB.addActionListener(listener);
+    toolBar.add(novaB);
+
+    JButton ulozitB = new JButton();
+    ulozitB.setIcon(IconFactory.getIcon("demos/nurbs/icons/adept_sourceseditor.png"));
+    // ulozitB.setText("Uložit");
+    ulozitB.setToolTipText("Save");
+    ulozitB.setActionCommand(ULOZIT_AC);
+    ulozitB.addActionListener(listener);
+    toolBar.add(ulozitB);
+
+    JButton nahratB = new JButton();
+    // nahratB.setText("Nahrát");
+    nahratB.setToolTipText("Load surface");
+    nahratB.setIcon(IconFactory.getIcon("demos/nurbs/icons/fileimport.png"));
+    nahratB.setActionCommand(NACIST_AC);
+    nahratB.addActionListener(listener);
+    toolBar.add(nahratB);
+
+    toolBar.add(new JToolBar.Separator());
+
+    JToggleButton pridatTB = new JToggleButton();
+    // pridatTB.setText("Přidat body");
+    pridatTB.setToolTipText("Add contol points");
+    toolBar.add(pridatTB);
+    pridatTB.setIcon(IconFactory.getIcon("demos/nurbs/icons/add.png"));
+    //		pridatTB.setActionCommand(PRIDAT_AC);
+    //		pridatTB.addActionListener(listener);
+		
+    bg.add(pridatTB);
+		
+    final JPopupMenu popup2=new JPopupMenu();
+    JMenuItem radkyPopupMI=new JMenuItem("Poits row");
+    radkyPopupMI.setActionCommand(PRIDAT_AC_RADEK);
+    JMenuItem sloupcePopupMI=new JMenuItem("Points column");
+    sloupcePopupMI.setActionCommand(PRIDAT_AC_SLOUPEC);
+    radkyPopupMI.addActionListener(listener);
+    sloupcePopupMI.addActionListener(listener);
+		
+    popup2.add(radkyPopupMI);
+    popup2.add(sloupcePopupMI);
+		
+    pridatTB.addMouseListener(new 
+                              /**
+                               * CLass to add context menu to toolbar button
+                               * Třída pro připojení kontextového menu na
+                               *         tlačítko na liště nástrojů
+                               * @author Tomáš Hráský 
+                               */
+                              MouseAdapter() {
+
+        @Override
+          public void mouseClicked(MouseEvent e) {
+          super.mouseClicked(e);
+          e.isPopupTrigger();
+          popup2.show(e.getComponent(), e.getX(), e.getY());
+        }
+			
+			
+      });
+		
+    JToggleButton smazatTB = new JToggleButton();
+    // smazatTB.setText("Smazat body");
+    smazatTB.setToolTipText("Delete points");
+    toolBar.add(smazatTB);
+    smazatTB.setIcon(IconFactory.getIcon("demos/nurbs/icons/fileclose.png"));
+    //		smazatTB.setActionCommand(SMAZAT_AC);
+    //		smazatTB.addActionListener(listener);
+    bg.add(smazatTB);
+		
+    final JPopupMenu popup3=new JPopupMenu();
+    JMenuItem radky2PopupMI=new JMenuItem("Points row");
+    radky2PopupMI.setActionCommand(SMAZAT_AC_RADEK);
+    JMenuItem sloupce2PopupMI=new JMenuItem("Points column");
+    sloupce2PopupMI.setActionCommand(SMAZAT_AC_SLOUPEC);
+    radky2PopupMI.addActionListener(listener);
+    sloupce2PopupMI.addActionListener(listener);
+		
+    popup3.add(radky2PopupMI);
+    popup3.add(sloupce2PopupMI);
+
+		
+    smazatTB.addMouseListener(new 
+                              /**
+                               * CLass to add context menu to toolbar button
+                               * Třída pro připojení kontextového menu na
+                               *         tlačítko na liště nástrojů
+                               * @author Tomáš Hráský 
+                               */
+                              MouseAdapter() {
+
+        @Override
+          public void mouseClicked(MouseEvent e) {
+          super.mouseClicked(e);
+          e.isPopupTrigger();
+          popup3.show(e.getComponent(), e.getX(), e.getY());
+        }
+			
+			
+      });
+		
+    JToggleButton stupenTB = new JToggleButton();
+    // stupenTB.setText("Smazat body");
+    stupenTB.setToolTipText("Set surface degree");
+    toolBar.add(stupenTB);
+    stupenTB.setIcon(IconFactory.getIcon("demos/nurbs/icons/math_rsup.png"));
+    stupenTB.setActionCommand(STUPEN_AC);
+    stupenTB.addActionListener(listener);
+    bg.add(stupenTB);
+
+    final JPopupMenu popup = new JPopupMenu();
+
+    JMenuItem uzavrenyPopupMI = new JMenuItem("Clamped");
+    popup.add(uzavrenyPopupMI);
+    uzavrenyPopupMI.setActionCommand(UZAVRENY_AC);
+    uzavrenyPopupMI.addActionListener(listener);
+    JMenuItem otevrenyPopupMI = new JMenuItem("Uniform");
+    popup.add(otevrenyPopupMI);
+    otevrenyPopupMI.setActionCommand(OTEVRENY_AC);
+    otevrenyPopupMI.addActionListener(listener);
+
+    JToggleButton vytvoritButton = new JToggleButton();
+    // vytvoritButton.setText("Vytvořit uzlový vektor");
+    vytvoritButton.setToolTipText("Create knotvectors");
+    vytvoritButton.setIcon(IconFactory.getIcon("demos/nurbs/icons/newfunction.png"));
+    bg.add(vytvoritButton);
+
+    vytvoritButton.addMouseListener(new
+                                    /**
+                                     * CLass to add context menu to toolbar button
+                                     * Třída pro připojení kontextového menu na
+                                     *         tlačítko na liště nástrojů
+                                     * @author Tomáš Hráský 
+                                     */
+                                    MouseAdapter() {
+
+        @Override
+          public void mouseClicked(MouseEvent e) {
+          super.mouseClicked(e);
+          e.isPopupTrigger();
+          popup.show(e.getComponent(), e.getX(), e.getY());
+        }
+
+      });
+    popup.setInvoker(vytvoritButton);
+    toolBar.add(vytvoritButton);
+
+    moveTB = new JToggleButton();
+    // moveTB.setText("Hýbat body");
+    moveTB.setToolTipText("Move points");
+    moveTB.setIcon(IconFactory.getIcon("demos/nurbs/icons/mouse.png"));
+    toolBar.add(moveTB);
+    moveTB.setActionCommand(MOVE_AC);
+    moveTB.addActionListener(listener);
+    bg.add(moveTB);
+    toolBar.add(new JToolBar.Separator());
+    JButton infoB = new JButton();
+    // infoB.setText("Ukončit");
+    infoB.setToolTipText("About");
+
+    infoB.setIcon(IconFactory.getIcon("demos/nurbs/icons/info.png"));
+    toolBar.add(infoB);
+    infoB.setActionCommand(INFO_AC);
+    infoB.addActionListener(listener);
+    toolBar.add(new JToolBar.Separator());
+
+    JButton exitB = new JButton();
+    // exitB.setText("Ukončit");
+    exitB.setToolTipText("Exit");
+
+    exitB.setIcon(IconFactory.getIcon("demos/nurbs/icons/exit.png"));
+    toolBar.add(exitB);
+    exitB.setActionCommand(EXIT_AC);
+    exitB.addActionListener(listener);
+
+    c.gridwidth = 1;
+
+    c.gridx = 0;
+    c.gridy = 2;
+
+    c.weightx = 1;
+    c.weighty = 1;
+
+    getContentPane().add(glCanvas, c);
+    c.gridx = 1;
+    JPanel rightPanel = new JPanel(new GridBagLayout());
+    GridBagConstraints cc = new GridBagConstraints();
+    cc.insets = new Insets(5, 5, 5, 5);
+    xSpinner = new JSpinner(new SpinnerNumberModel(0, -10000, 10000.0, 1));
+    ySpinner = new JSpinner(new SpinnerNumberModel(0, -10000.0, 10000.0, 1));
+    zSpinner = new JSpinner(new SpinnerNumberModel(0, -10000.0, 10000.0, 1));
+    wSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 10000.0, .05));
+
+    SpinnerListener spinnerListener = new SpinnerListener(this);
+    SliderListener sliderListener=new SliderListener(this);
+		
+    xSpinner.addChangeListener(spinnerListener);
+    xSpinner.setName(X_SPINNER_NAME);
+    ySpinner.addChangeListener(spinnerListener);
+    ySpinner.setName(Y_SPINNER_NAME);
+    wSpinner.addChangeListener(spinnerListener);
+    wSpinner.setName(W_SPINNER_NAME);
+		
+    zSpinner.setName(Z_SPINNER_NAME);
+    zSpinner.addChangeListener(spinnerListener);
+
+    cc.gridx = 0;
+    cc.gridy = 0;
+    cc.gridwidth = 2;
+    cc.weighty = 0;
+
+    rotaceXLabel = new JLabel();
+    rightPanel.add(rotaceXLabel, cc);
+    cc.gridy++;
+
+    rotaceXSlider = new JSlider(-180, 180, 0);
+    rotaceXSlider.addChangeListener(sliderListener);
+    rightPanel.add(rotaceXSlider, cc);
+    cc.gridy++;
+
+    rotaceYLabel = new JLabel();
+    rightPanel.add(rotaceYLabel, cc);
+    cc.gridy++;
+
+    rotaceYSlider = new JSlider(-180, 180, 0);
+    rotaceYSlider.addChangeListener(sliderListener);
+    rightPanel.add(rotaceYSlider, cc);
+    cc.gridy++;
+
+    rotaceZLabel = new JLabel();
+    rightPanel.add(rotaceZLabel, cc);
+    cc.gridy++;
+
+    rotaceZSlider = new JSlider(-180, 180, 0);
+    rotaceZSlider.addChangeListener(sliderListener);
+    rightPanel.add(rotaceZSlider, cc);
+    cc.gridy++;
+		
+    lightingChBox=new JCheckBox(new 
+                                /**
+                                 * Class for easy reaction to checkbox event
+                                 * Třída pro jendoduché zpracování akce na checkboxu 
+                                 * @author Tomáš Hráský
+                                 */	
+                                AbstractAction("Show Bézier plates"){
+
+        public void actionPerformed(ActionEvent e) {
+          updateGLCanvas();				
+        }
+			
+      });
+    lightingChBox.setSelected(false);
+		
+    rightPanel.add(lightingChBox,cc);
+		
+    cc.gridy++;
+
+    updateRotationLabels();
+		
+    cc.weighty = 1;
+    rightPanel.add(new JPanel(), cc);
+    cc.weighty = 0;
+    cc.gridwidth = 1;
+
+    cc.gridy++;
+    rightPanel.add(new JLabel("X"), cc);
+    cc.gridy++;
+    rightPanel.add(new JLabel("Y"), cc);
+    cc.gridy++;
+    rightPanel.add(new JLabel("Z"), cc);
+    cc.gridy++;
+    rightPanel.add(new JLabel("W"), cc);
+
+    cc.gridx = 1;
+    cc.gridy -= 3;
+    rightPanel.add(xSpinner, cc);
+    cc.gridy++;
+    rightPanel.add(ySpinner, cc);
+    cc.gridy++;
+    rightPanel.add(zSpinner, cc);
+    cc.gridy++;
+    rightPanel.add(wSpinner, cc);
+
+    xSpinner.setEnabled(false);
+    ySpinner.setEnabled(false);
+    zSpinner.setEnabled(false);
+    wSpinner.setEnabled(false);
+
+    c.weightx = 0;
+    c.weighty = 0;
+    getContentPane().add(rightPanel, c);
+
+    c.gridx = 0;
+    c.gridy++;
+
+    knotSlider = new JKnotSlider(Surface.getInstance().getKnotsU());
+    knotSlider.addActionListener(this);
+    knotSlider.setName(U_KNOTSLIDER);
+    getContentPane().add(knotSlider, c);
+
+    c.gridy++;
+    knotSlider2 = new JKnotSlider(Surface.getInstance().getKnotsU());
+    knotSlider2.addActionListener(this);
+    knotSlider2.setName(V_KNOTSLIDER);
+    getContentPane().add(knotSlider2, c);
+
+    pack();
+    invalidate();
+    setVisible(true);
+  }
+
+  /**
+   * Method for running application
+   * Metoda pro spuštění aplikace
+   * 
+   * @param args
+   * 	no arguments from command line
+   * 
+   */
+  public static void main(String[] args) {
+    new SurfaceApp();
+
+  }
+
+  /**
+   * Reaction to reqest for canvas redraw - redraws canvas and sets coords of actually selected control point to editing components
+   * Reakce na požadavek překreslení OpenGL plátna, překreslí plátno a nastaví
+   * souřadnice aktuálního vybraného bodu do editačních komponent
+   */
+  public void updateGLCanvas() {
+    glCanvas.repaint();
+    if (Surface.getInstance().getBodIndex() >= 0) {
+      xSpinner.setEnabled(true);
+      ySpinner.setEnabled(true);
+      zSpinner.setEnabled(true);
+      wSpinner.setEnabled(true);
+
+      xSpinner.setValue(Double.valueOf(Math.round(Surface.getInstance()
+                                                  .getActiveX())));
+      ySpinner.setValue(Double.valueOf(Math.round(Surface.getInstance()
+                                                  .getActiveY())));
+      zSpinner.setValue(Double.valueOf(Math.round(Surface.getInstance()
+                                                  .getActiveZ())));
+      wSpinner.setValue(Double
+                        .valueOf(Surface.getInstance().getActiveW()));
+    } else {
+      xSpinner.setEnabled(false);
+      ySpinner.setEnabled(false);
+      zSpinner.setEnabled(false);
+      wSpinner.setEnabled(false);
+    }
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
+   */
+  public void actionPerformed(ActionEvent e) {
+    if (e.getSource() instanceof JKnotSlider) {
+      JKnotSlider src = (JKnotSlider) e.getSource();
+      if (src.getName().equals(U_KNOTSLIDER)) {
+        if(src.checkKnotMulti(Surface.getInstance().getOrderU())){
+          Surface.getInstance().setKnotsU(src.getKnotsFloat());
+        }else{
+          JOptionPane.showMessageDialog(this,"Maximum knot multiplicity exceeded","Error",JOptionPane.ERROR_MESSAGE);
+          src.setKnots(Surface.getInstance().getKnotsU());
+        }
+
+      } else {
+        if(src.checkKnotMulti(Surface.getInstance().getOrderV())){
+          Surface.getInstance().setKnotsV(src.getKnotsFloat());
+        }else{
+          JOptionPane.showMessageDialog(this,"Maximum knot multiplicity exceeded","Error",JOptionPane.ERROR_MESSAGE);
+          //JOptionPane.showMessageDialog(this,"Překročení maximální násobnosti uzlu","Chyba",JOptionPane.ERROR_MESSAGE);
+          src.setKnots(Surface.getInstance().getKnotsV());
+        }
+      }
+      updateGLCanvas();
+    }
+  }
+
+  /**
+   * Returns OpenGL canvas
+   * Vrací OpenGL plátno
+   * 
+   * @return OpenGL canvas
+   */
+  public GLCanvas getGlCanvas() {
+    return glCanvas;
+  }
+
+  /**
+   * Returns mouse listener
+   * Vrací listener událostí myši
+   * 
+   * @return mouse listener
+   */
+  public SurfaceMouseListener getMouseListener() {
+    return mouseListener;
+  }
+
+  /**
+   * Creates NURBS surface with clamped knotvectors
+   * Vytvoří NURBS plochu s okrajovými uzlovými vektory
+   */
+  public void uzavernyKV() {
+    int stupen;
+    int pocetBodu;
+    boolean isOK=true;
+    float[] newKnots = null,newKnotsV = null;
+		
+    stupen= Surface.getInstance().getOrderU();
+    pocetBodu= Surface.getInstance().getPointsInU();
+    if (stupen <= pocetBodu) {
+      int knotCount = stupen + pocetBodu;
+      int middlePartSize = knotCount - 2 * stupen;
+      newKnots = new float[knotCount];
+      int i;
+      int j = 0;
+      float middleStep = 1f / (middlePartSize + 2);
+      float knot = middleStep;
+
+      // knot=.5f;
+
+      for (i = 0; i < stupen; i++)
+        newKnots[j++] = 0;
+      for (i = 0; i < middlePartSize; i++) {
+        newKnots[j++] = knot;
+        knot += middleStep;
+      }
+      for (i = 0; i < stupen; i++)
+        newKnots[j++] = 1;
+
+			
+
+    } else{
+      isOK=false;
+      //errorMessage("Malý počet řídících bodů ve směru paramteru U vzhledem k zadanému stupni plochy");
+      errorMessage("Too few control points as of U degree");
+    }
+		
+    stupen= Surface.getInstance().getOrderV();
+    pocetBodu= Surface.getInstance().getPointsInV();
+    if (stupen <= pocetBodu) {
+      int knotCount = stupen + pocetBodu;
+      int middlePartSize = knotCount - 2 * stupen;
+      newKnotsV = new float[knotCount];
+      int i;
+      int j = 0;
+      float middleStep = 1f / (middlePartSize + 2);
+      float knot = middleStep;
+
+      // knot=.5f;
+
+      for (i = 0; i < stupen; i++)
+        newKnotsV[j++] = 0;
+      for (i = 0; i < middlePartSize; i++) {
+        newKnotsV[j++] = knot;
+        knot += middleStep;
+      }
+      for (i = 0; i < stupen; i++)
+        newKnotsV[j++] = 1;
+
+			
+
+    } else{
+      isOK=false;
+      //errorMessage("Malý počet řídících bodů ve směru paramteru V vzhledem k zadanému stupni plochy");
+      errorMessage("Too few control points as of V degree");
+    }
+		
+    if(isOK)
+      postNewKnot(newKnots,newKnotsV);
+  }
+
+  /**
+   * Shows modal window with error report
+   * Zobrazí modální okno s hlášením chyby
+   * 
+   * @param error
+   * 	error report
+   */
+
+  public void errorMessage(String error) {
+    JOptionPane.showMessageDialog(this, error, "Error!",
+                                  JOptionPane.ERROR_MESSAGE);
+  }
+
+  /**
+   * Creates NURBS surface with uniform knotvectors
+   * Vytvoří NURBS plochu s uniformními uzlovými vektory
+   */
+  public void otevrenyKV() {
+    int stupen,pocetBodu;
+		
+    boolean isOK=true;
+    float[] newKnots = null,newKnotsV = null;
+
+		
+    stupen = Surface.getInstance().getOrderU();
+    pocetBodu = Surface.getInstance().getPointsInU();
+    if (stupen <= pocetBodu) {
+      int knotCount = stupen + pocetBodu;
+      int middlePartSize = knotCount;
+      newKnots = new float[knotCount];
+      int i;
+      int j = 0;
+      float middleStep = 1f / (middlePartSize - 1);
+      float knot = 0;
+
+      for (i = 0; i < middlePartSize; i++) {
+        newKnots[j++] = knot;
+        knot += middleStep;
+      }
+
+			
+    } else{
+      isOK=false;
+      //errorMessage("Malý počet řídících bodů ve směru parametru U vzhledem k zadanému stupni plochy");
+      errorMessage("Too few control points as of U degree");
+    }
+		
+    stupen = Surface.getInstance().getOrderV();
+    pocetBodu = Surface.getInstance().getPointsInV();
+    if (stupen <= pocetBodu) {
+      int knotCount = stupen + pocetBodu;
+      int middlePartSize = knotCount;
+      newKnotsV = new float[knotCount];
+      int i;
+      int j = 0;
+      float middleStep = 1f / (middlePartSize - 1);
+      float knot = 0;
+
+      for (i = 0; i < middlePartSize; i++) {
+        newKnotsV[j++] = knot;
+        knot += middleStep;
+      }
+
+					
+    } else{
+      isOK=false;
+      //errorMessage("Malý počet řídících bodů ve směru parametru V vzhledem k zadanému stupni plochy");
+      errorMessage("Too few control points as of V degree");
+    }
+		
+    if(isOK)
+      postNewKnot(newKnots,newKnotsV);	
+
+  }
+	
+
+  /**
+   * Method called after adding new knot
+   * Metoda volaná po přidání nového uzlu
+   * @param newKnots new U knotvector
+   * @param newKnotsV new V knotvector
+   */
+  private void postNewKnot(float[] newKnots,float[] newKnotsV) {
+    Surface.getInstance().setKnotsU(newKnots);
+    Surface.getInstance().setKnotsV(newKnotsV);
+    knotSlider.setKnots(newKnots);
+    knotSlider2.setKnots(newKnotsV);
+    Surface.getInstance().setIsSurfaceFinished(true);
+    updateGLCanvas();
+    moveTB.setSelected(true);
+  }
+
+  /**
+   * Activates move mode button
+   * Aktivuje tlačítko módu pohybu řícími body
+   */
+  public void selectMoveButt() {
+    moveTB.setSelected(true);
+  }
+
+  /**
+   * Sets datasource for editation of knotvectors from surface definition object
+   * Nastaví zdroje dat komponent pro editaci uzlových vektorů podle uz.
+   * vektorů v objektu plochy
+   */
+  public void updateJKnotSlider() {
+    knotSlider.setKnots(Surface.getInstance().getKnotsU());
+    knotSlider2.setKnots(Surface.getInstance().getKnotsV());
+  }
+
+  /**
+   * Returns value of X axe rotation set in editing component
+   * Vrací hodnotu rotace kolem osy X nastavenou v editační komponentě 
+   * @return X rotation
+   */
+  public float getXrotation() {
+    return rotaceXSlider.getValue();
+  }
+	
+  /**
+   * Returns value of Y axe rotation set in editing component
+   * Vrací hodnotu rotace kolem osy Y nastavenou v editační komponentě 
+   * @return Y rotation
+   */
+  public float getYrotation() {
+    return rotaceYSlider.getValue();
+  }
+	
+  /**
+   * Returns value of Z axe rotation set in editing component
+   * Vrací hodnotu rotace kolem osy Z nastavenou v editační komponentě 
+   * @return Z rotation
+   */
+  public float getZrotation() {
+    return rotaceZSlider.getValue();
+  }
+	
+  /**
+   * Updates labels's text according to their actual state
+   * Upraví text popisků prvků pro ovládání rotace podle jejich aktuálního stavu
+   */
+  public void updateRotationLabels(){
+    String zakladniText = "Rotation by axe ";
+		
+    PrintfFormat format=new PrintfFormat("%0.3d");
+    String add;
+    if(rotaceXSlider.getValue()<0)add="-";
+    else add="+";
+    rotaceXLabel.setText(zakladniText+"X "+add+format.sprintf(Math.abs(rotaceXSlider.getValue()))+"˚");
+    if(rotaceYSlider.getValue()<0)add="-";
+    else add="+";
+    rotaceYLabel.setText(zakladniText+"Y "+add+format.sprintf(Math.abs(rotaceYSlider.getValue()))+"˚");
+    if(rotaceZSlider.getValue()<0)add="-";
+    else add="+";	
+    rotaceZLabel.setText(zakladniText+"Z "+add+format.sprintf(Math.abs(rotaceZSlider.getValue()))+"˚");
+  }
+
+  /**
+   * Return OpenGL canvas listener
+   * Vrací listener OpenGL plátna
+   * @return OpenGL canvas listener
+   */
+  public GLListener getGlListener() {
+    return glListener;
+  }
+
+  /**
+   * Notifies about reqest to light surface
+   * Informuje o požadavku na nasvětlení tělesa
+   * @return true if lighting is enabled
+   */
+  public boolean isLightingEnabled() {
+    return !lightingChBox.isSelected();
+  }
+}