c pete sans ca

src/main/java/CuisineHTTPServer.java

     {
         try {
             sHtml_ASCII_title = new Scanner(CuisineHTTPServer.class.getResourceAsStream("html_ascii_title"), "UTF-8").useDelimiter("\\A").next();
-            sHtml_CSS = new Scanner(CuisineHTTPServer.class.getResourceAsStream("style.css"), "UTF-8").useDelimiter("\\A").next();
-            sJS_ClientSide = new Scanner(CuisineHTTPServer.class.getResourceAsStream("clientsidecoms.js"), "UTF-8").useDelimiter("\\A").next();
-            sHtml_Chatbox = new Scanner(CuisineHTTPServer.class.getResourceAsStream("components/chat.html"), "UTF-8").useDelimiter("\\A").next();
-            sJS_Chatbox = new Scanner(CuisineHTTPServer.class.getResourceAsStream("components/chatscript.js"), "UTF-8").useDelimiter("\\A").next();
-
+            sHtml_CSS       = new Scanner(CuisineHTTPServer.class.getResourceAsStream("style.css"), "UTF-8").useDelimiter("\\A").next();
+            sJS_ClientSide  = new Scanner(CuisineHTTPServer.class.getResourceAsStream("clientsidecoms.js"), "UTF-8").useDelimiter("\\A").next();
+            sHtml_Chatbox   = new Scanner(CuisineHTTPServer.class.getResourceAsStream("components/chat.html"), "UTF-8").useDelimiter("\\A").next();
+            sJS_Chatbox     = new Scanner(CuisineHTTPServer.class.getResourceAsStream("components/chatscript.js"), "UTF-8").useDelimiter("\\A").next();
         }
         catch(Exception vex)
         {

src/main/java/websockets/CuisineWebSocketServer.java

 
 import io.undertow.Undertow;
 import io.undertow.websockets.WebSocketConnectionCallback;
-import io.undertow.websockets.core.AbstractReceiveListener;
-import io.undertow.websockets.core.BufferedTextMessage;
 import io.undertow.websockets.core.WebSocketChannel;
-import io.undertow.websockets.core.WebSockets;
 import io.undertow.websockets.spi.WebSocketHttpExchange;
+import org.xnio.ChannelListener;
 import tcp.CuisineTCPServer;
-
-import java.util.ArrayList;
+import websockets.handlers.CuisineWebSocketReceiveHandler;
+import websockets.handlers.CuisineWebSocketWebSocketChichatHandler;
+import websockets.handlers.CuisineWebSocketWebSocketTemperatureHandler;
 
 import static io.undertow.Handlers.path;
 import static io.undertow.Handlers.websocket;
-import static io.undertow.Handlers.*;
 
 public class CuisineWebSocketServer {
 
     CuisineWebSocketConnectionHandler fConnectionHandler;
     CuisineWebSocketConnectionHandler fChatConnectionHandler;
-    CuisineWebSocketMessageHandler fMessageHandler;
-    CuisineWebSocketChichatHandler fChitchatMessageHandler;
+    CuisineWebSocketWebSocketTemperatureHandler fMessageHandler;
+    CuisineWebSocketWebSocketChichatHandler fChitchatMessageHandler;
     Undertow fWebSocketServer;
     String fWebSocketHost;
     int fWebSocketPort;
+    int fConnectedClients;
 
     public CuisineWebSocketServer(String iHost, int iPort
     ) {
     }
 
     public void initTCPServer(CuisineTCPServer iTcpServer) {
-        fMessageHandler = new CuisineWebSocketMessageHandler(iTcpServer);
+        fMessageHandler = new CuisineWebSocketWebSocketTemperatureHandler(iTcpServer);
     }
 
     public void start() {
-        fChitchatMessageHandler = new CuisineWebSocketChichatHandler();
+        fChitchatMessageHandler = new CuisineWebSocketWebSocketChichatHandler();
 
         fConnectionHandler = new CuisineWebSocketConnectionHandler(fMessageHandler);
         fChatConnectionHandler = new CuisineWebSocketConnectionHandler(fChitchatMessageHandler);
 
 
     private class CuisineWebSocketConnectionHandler implements WebSocketConnectionCallback {
-        private AbstractReceiveListener fWebSocketMessageHandler;
+        private CuisineWebSocketReceiveHandler fWebSocketMessageHandler;
 
-        protected CuisineWebSocketConnectionHandler(AbstractReceiveListener iWebSocketMessageHandler) {
+        protected CuisineWebSocketConnectionHandler(CuisineWebSocketReceiveHandler iWebSocketMessageHandler) {
             fWebSocketMessageHandler = iWebSocketMessageHandler;
         }
 
         @Override
         public void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel) {
             channel.getReceiveSetter().set(fWebSocketMessageHandler);
+            fWebSocketMessageHandler.register(channel);
+            channel.addCloseTask(new ChannelListener<WebSocketChannel>(){
+
+                @Override
+                public void handleEvent(WebSocketChannel channel) {
+                    fWebSocketMessageHandler.unregister(channel);
+                    System.out.println(channel.getPeerAddress());
+                    System.out.println("Connection closed");
+                }
+            });
             channel.resumeReceives();
         }
-    }
-
-    private class CuisineWebSocketMessageHandler extends AbstractReceiveListener {
-
-        private CuisineTCPServer fTCPServer;
-
-        protected CuisineWebSocketMessageHandler(CuisineTCPServer iTCPServer) {
-            super();
-            fTCPServer = iTCPServer;
-        }
 
-        protected void onFullTextMessage(WebSocketChannel iChannel, BufferedTextMessage iTextMessage) {
-            //Handle message on webSocket
-            WebSockets.sendText(String.valueOf(fTCPServer.getCurrentTemperature()), iChannel, null);
-        }
     }
 
+
 }

src/main/java/websockets/handlers/CuisineWebSocketReceiveHandler.java

 import io.undertow.websockets.core.AbstractReceiveListener;
 import io.undertow.websockets.core.WebSocketChannel;
 
-public class CuisineReceiveListener extends AbstractReceiveListener {
+import java.util.ArrayList;
 
-    public void register(WebSocketChannel iChannel)
+public class CuisineWebSocketReceiveHandler extends AbstractReceiveListener {
+
+    private ArrayList <WebSocketChannel> fRegisteredChannels;
+
+    protected CuisineWebSocketReceiveHandler()
+    {
+        super();
+        fRegisteredChannels = new ArrayList<>();
+    }
+
+    public ArrayList <WebSocketChannel> getRegisteredChannels()
     {
+        return fRegisteredChannels;
+    }
 
+    public void register(WebSocketChannel iChannel)
+    {
+        fRegisteredChannels.add(iChannel);
     }
 
     public void unregister(WebSocketChannel iChannel)
     {
-
+        fRegisteredChannels.remove(iChannel);
     }
 }

src/main/java/websockets/handlers/CuisineWebSocketWebSocketChichatHandler.java

 package websockets.handlers;
 
-import io.undertow.websockets.core.AbstractReceiveListener;
 import io.undertow.websockets.core.BufferedTextMessage;
 import io.undertow.websockets.core.WebSocketChannel;
 import io.undertow.websockets.core.WebSockets;
 
 import java.util.ArrayList;
 
-public class CuisineWebSocketChichatHandler extends CuisineReceiveListener {
+public class CuisineWebSocketWebSocketChichatHandler extends CuisineWebSocketReceiveHandler {
 
     final int MAX_MESSAGES = 10;
     ArrayList<String> vMessageHistory;
 
-    public CuisineWebSocketChichatHandler() {
+    public CuisineWebSocketWebSocketChichatHandler() {
+        super();
         vMessageHistory = new ArrayList<>();
     }
 
             vBuilder.append(vMessage+"\n");
         }
 
-        WebSockets.sendText(vBuilder.toString(), iChannel, null);
+        String vMessage = vBuilder.toString();
+        notifyOthers(vMessage);
+        WebSockets.sendText(vMessage, iChannel, null);
+
     }
 
     public void register(WebSocketChannel iChannel)
     {
-
+        super.register(iChannel);
     }
 
     public void unregister(WebSocketChannel iChannel)
     {
-
+        super.unregister(iChannel);
     }
 
     protected void notifyOthers(String iMessages)
     {
-        Websockets.sendText(iMessages)
+        for( WebSocketChannel vChannel : this.getRegisteredChannels() )
+        {
+            WebSockets.sendText(iMessages, vChannel,null);
+        }
     }
 
 }

src/main/java/websockets/handlers/CuisineWebSocketWebSocketTemperatureHandler.java

 import io.undertow.websockets.core.WebSockets;
 import tcp.CuisineTCPServer;
 
-public class CuisineWebSocketWebSocketMessageHandler extends CuisineWebSocketReceiveHandler {
+public class CuisineWebSocketWebSocketTemperatureHandler extends CuisineWebSocketReceiveHandler {
 
     private CuisineTCPServer fTCPServer;
 
-    public CuisineWebSocketWebSocketMessageHandler(CuisineTCPServer iTCPServer) {
+    public CuisineWebSocketWebSocketTemperatureHandler(CuisineTCPServer iTCPServer) {
         super();
         fTCPServer = iTCPServer;
     }

src/main/resources/components/chat.html

 <div id="chatbox" >
-    <div id="chatboxcontent">
+    <div id="chatboxcontent" class="tile">
 
     </div>
-    <div id="chatboxinput">
+    <form id="chatboxinput" action="javascript:void(0);">
         <input type="text" id="chatboxinputtext">
-        <input type="button" id="chatboxinputbutton" value="ok"/>
-    </div>
+        <input type="submit"  action="submit" id="chatboxinputbutton" value="ok"/>
+    </form>
 </div>

src/main/resources/components/chatscript.js

 
     let chatInput = document.getElementById("chatboxinputtext");
 
-    let chatInputButton = document.getElementById("chatboxinputbutton");
-    chatInputButton.onclick = function()
+    let chatInputButton = document.getElementById("chatboxinput");
+    chatInputButton.onsubmit = function()
     {
         input = chatInput.value;
+        chatInput.value="";
         console.log(input);
         chatSocket.send(input);
     };
 
     chatSocket.onerror=function(error){connected=false;view.innerHTML="oups :(";};
-    chatSocket.onmessage=function(event){view.innerHTML="<pre>"+event.data+"</pre>";};
+    chatSocket.onmessage=function(event){view.innerHTML=event.data;};
     chatSocket.onopen=function(e){connected=true;callServer();};
     var callServer=function(){
         chatSocket.send("R0VU");
     };
 
-    let timer=setInterval(callServer,1000);
+   // let timer=setInterval(callServer,1000);
 
 });

src/main/resources/style.css

     white-space: pre;
 }
 
+.tile{
+    display: bloc;
+    width: 25%;
+    overflow-x: hidden;
+    overflow-y: auto;
+    white-space: pre-line;
+    word-wrap: break-word;
+}
+
 .centered{
     margin : auto;
     display: bloc;