VisClient/org/hfbk/vis/visnode/VisKeyboard.java

Go to the documentation of this file.

package org.hfbk.vis.visnode;

import java.awt.AWTEvent;
import java.awt.AWTException;
import java.awt.Component;
import java.awt.Container;
import java.awt.Frame;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.HashMap;
import java.util.List;

import org.dronus.gl.GLFont;
import org.dronus.gl.GLTextPanel;
import org.dronus.gl.GLUtil;
import org.hfbk.vis.Prefs;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector3f;

public class VisKeyboard extends VisNode implements VisUI{

        Component focus;
        
        Robot keybot; //for key automation on OS layer.
                                //this is much more convenient than
                                //using the internal message system 
                                //as the keys-to-char mapping is 
                                //quite complicated and OS governed.

        public boolean enabled=true;
        
        boolean registered=false;       
        
        class VisKey extends VisNodeMousable{

                GLTextPanel tp;
                int keycode;
                public VisKey(String key, int keycode, Vector3f position) {
                        super(null, position);
                        tp=new GLTextPanel(key,0,0);
                        w=Math.max(1f,tp.w/2); h=1;
                        this.keycode=keycode;                   
                }
                
                void handleEvent(VisMouseEvent evt) {
                        //if (evt.getID()==MouseEvent.MOUSE_CLICKED || evt.getID()==MouseEvent.MOUSE_DRAGGED)
                        if (evt.getID()==MouseEvent.MOUSE_CLICKED )
                                handleKey(keycode);
                }

                void renderSelf() {
                        
                        GL11.glDisable(GL11.GL_TEXTURE_2D);
                        GL11.glColor4f(.3f,.3f,.3f,.9f);
                        GL11.glPolygonOffset(1, 1);
                        GLUtil.renderQuad(-w/2, -h/2,w/2,h/2);
                        
                        GL11.glPolygonOffset(0, 0);                     
                        GL11.glColor3f(1,1,1);                  
                        GLFont.getDefault().render();                   
                        GL11.glTranslatef(-tp.w/4,-tp.h/3,0);
                        GL11.glScalef(.4f,.8f,.4f);                     
                        tp.render();
                }
                
        }
        

        static final int NEXTROW=-1;
        
        static int[] keylayout=new int[]{
                        KeyEvent.VK_ESCAPE,     KeyEvent.VK_1, KeyEvent.VK_2, KeyEvent.VK_3, KeyEvent.VK_4,KeyEvent.VK_5, 
                                KeyEvent.VK_6, KeyEvent.VK_7,   KeyEvent.VK_8, KeyEvent.VK_9,KeyEvent.VK_0,
                                KeyEvent.VK_BACK_SPACE, NEXTROW,
        
                        KeyEvent.VK_TAB, KeyEvent.VK_Q, KeyEvent.VK_W,  KeyEvent.VK_E,  KeyEvent.VK_R,  KeyEvent.VK_T,  KeyEvent.VK_Z,
                                KeyEvent.VK_U,  KeyEvent.VK_I,  KeyEvent.VK_O,  KeyEvent.VK_P,  KeyEvent.VK_PLUS, NEXTROW,
                        
                        KeyEvent.VK_CAPS_LOCK,KeyEvent.VK_A,KeyEvent.VK_S,KeyEvent.VK_D,KeyEvent.VK_F,KeyEvent.VK_G,KeyEvent.VK_H,
                                KeyEvent.VK_J,KeyEvent.VK_K,KeyEvent.VK_L,KeyEvent.VK_ENTER,NEXTROW,
                        
                        KeyEvent.VK_LESS,KeyEvent.VK_Y, KeyEvent.VK_X,  KeyEvent.VK_C,  KeyEvent.VK_V,  KeyEvent.VK_B, KeyEvent.VK_N,
                                KeyEvent.VK_M,  KeyEvent.VK_COMMA,      KeyEvent.VK_PERIOD,     KeyEvent.VK_MINUS, NEXTROW,
                        
                        KeyEvent.VK_SPACE
        };
        static HashMap <Integer,String> keytexts= new HashMap<Integer,String>();
        static{
                keytexts.put(KeyEvent.VK_TAB,"|<-->|");
                keytexts.put(KeyEvent.VK_LESS,"< >");
                keytexts.put(KeyEvent.VK_ENTER,"ENTER");
                keytexts.put(KeyEvent.VK_PLUS,"+ *");
                keytexts.put(KeyEvent.VK_BACK_SPACE,"<-");              
                keytexts.put(KeyEvent.VK_COMMA,",");
                keytexts.put(KeyEvent.VK_PERIOD,".");
                keytexts.put(KeyEvent.VK_MINUS,"-");
                keytexts.put(KeyEvent.VK_CAPS_LOCK,"^");
                keytexts.put(KeyEvent.VK_SPACE,"                                           ");
        }
        
        public VisKeyboard() {
                super(null, new Vector3f(-6,3,-13));
                try {
                        keybot=new Robot();
                } catch (AWTException e) {                      
                        e.printStackTrace();
                }               
        }

        public void buildKeys(){
                float x=0,y=0;
                for (int i=0; i<keylayout.length; i++){

                        if (keylayout[i]==NEXTROW){
                                x=0; y+=1.2;
                                continue;
                        }
                        
                        String text=keytexts.get(keylayout[i]);
                        if (text==null)
                                text=KeyEvent.getKeyText(keylayout[i]);
                        
                        VisKey key=new VisKey(text, keylayout[i], new Vector3f(x,-y,0));
                        add(key);       
                        key.position.x+=key.w/2;
                        x+=.2f+key.w;
                }                       
        }
        
        public void handleKey(int keycode) {
                if (focus!=null)
                        focus.requestFocus();
                
                keybot.keyPress(keycode);
                keybot.keyRelease(keycode);
                
                if (keycode==KeyEvent.VK_ENTER || keycode==KeyEvent.VK_ESCAPE)
                        enabled=false;
                
        }


        void renderSelf() {}
        
        public void render(List<AWTEvent> events) {
                
                if(!registered) {
                        Component c=getRoot().client.panel;
                        while(!(c instanceof Frame)) c=c.getParent();
                        register(c);
                        registered=true;
                }
                
                if (enabled && Prefs.current.osk) {
                        if (children.size()==0)
                                buildKeys();
                        super.render(events);
                }
        }
        

        MouseListener clickListener=new MouseAdapter(){
                public void mouseClicked(MouseEvent e) {
                        Component source=e.getComponent();
                        if (source!=getRoot().client.panel){
                                focus=source;
                                enabled=true;
                        }
                }
        }; 
        
        public void register(Component c) {
                c.addMouseListener(clickListener);
                if (c instanceof Container)  //if this contains further elements register them as well
                        for (Component c2 : ((Container)c).getComponents())
                                register(c2);           
        }
}

---