wxruby-ruby19 1.9.10-x86-mingw32

data/samples/sockets/wxClient.rb

@@ -0,0 +1,395 @@
+#!/usr/bin/env ruby
+# wxRuby2 Sample Code. Copyright (c) 2007-???? Mario J. Steele
+# Freely reusable code: see SAMPLES-LICENSE.TXT for details
+
+# This sample is of a client impelmentation using Ruby's green
+# threads, Ruby's Asynchronous Sockets, and wxRuby Widgets, so as
+# to not block the GUI while waiting for data.
+
+begin
+  require 'wx'
+rescue LoadError => no_wx_err
+  begin
+    require 'rubygems'
+    require 'wx'
+  rescue LoadError
+    raise no_wx_err
+  end
+end
+
+require 'thread'   # For Thread and Mutex
+require 'socket'   # For TCP/IP Communications
+
+$LOAD_PATH << File.dirname(__FILE__)
+require 'wxSocketGUI'   # Our GUI Interface
+require 'SocketPackets' # For simplfying Socket communciation
+
+class String
+  # String#index_from(index,to_index)
+  # This finds the to_index from the index onwards till the end of the string.
+  # Returns the find_index + offset value of index.
+  def index_from(i,mtch)
+    self[i..-1].index(mtch) + i
+  end
+end
+
+
+class MyClientFrame < SocketGUI
+  include Socket::Constants
+  @@constants = %w[
+		ID_CONNECT
+		ID_DISCONNECT
+		ID_NAME
+		ID_EXIT
+		ID_TIMER_POLL
+	]
+  
+  # Creates the menus used by the Client.
+  def create_menus()
+    mb = Wx::MenuBar.new
+    
+    fileMenu = Wx::Menu.new
+    fileMenu.append(ID_CONNECT,"&Connect\tCtrl+S","Connect to a server")
+    fileMenu.append(ID_DISCONNECT,"&Disconnect\tCtrl+G","Disconnect from a server")
+    fileMenu.append_separator()
+    fileMenu.append(ID_NAME,"&Nickname\tCtrl+N","Set your nickname")
+    fileMenu.append_separator()
+    fileMenu.append(ID_EXIT,"E&xit\tCtrl+X","Exit the client")
+    
+    mb.append(fileMenu,"&File")
+    
+    set_menu_bar(mb)
+  end
+  
+  # Called from SocketGUI, to initialize our client window.
+  def on_init()
+    @nick = "Client"
+    @port = "1234"
+    @addr = $LOCALHOST_NAME
+    @mutex = Mutex.new
+    @buffer = ""
+    @timer = Wx::Timer.new(self,ID_TIMER_POLL)
+    
+    evt_menu(ID_CONNECT) { on_connect }
+    evt_menu(ID_DISCONNECT) { on_disconnect }
+    evt_menu(ID_NAME) { on_name }
+    evt_menu(ID_EXIT) { on_exit }
+    
+    evt_close { |evt| on_close(evt) }
+    evt_text_enter(@input.get_id) { on_text }
+    evt_timer(ID_TIMER_POLL) { Thread.pass }
+    
+    get_menu_bar.enable(ID_CONNECT,true)
+    get_menu_bar.enable(ID_DISCONNECT,false)
+  end
+  
+  # MyClientFrame#on_connect()
+  # Called from File > Connect, which prompts the user where they want to connect
+  # to, and starts the process for connecting to the server.  Since we're looking
+  # at a possibility of the connection not being completed immediately, we delegate
+  # the confirmation from the connection, to our polling loop here.  And we utilize
+  # the less known method Socket#connect_nonblock().  Oviously, Ruby will throw
+  # an exception if the connection isn't completed immedately, which is alright,
+  # we are expecting such.  So we ignore any errors, and process thoes in our poll
+  # loop for connecting.
+  def on_connect
+    unless @socket.nil?
+      Wx::message_box("You are already connected to a server!","Connect to...",Wx::ID_OK|Wx::ICON_ERROR)
+      return
+    end
+    msgbox = Wx::TextEntryDialog.new(self,"Enter the server you wish to connect to: (Default: #{$LOCALHOST_NAME}:1234)",
+                                      "Connect to server",@addr + ":" + @port.to_s)
+    ret = msgbox.show_modal
+    if ret == Wx::ID_CANCEL
+      return
+    end
+    @socket = Socket.new(AF_INET,SOCK_STREAM,0)
+    sockaddr = msgbox.get_value
+    unless sockaddr.index(":")
+      sockaddr += ":1234"
+    end
+    @host,@port = sockaddr.split(":")
+    sockaddr = Socket.sockaddr_in(@port,@host)
+    begin
+      @socket.connect_nonblock(sockaddr)
+    rescue
+      # We're polling for connection anyways
+    end
+    append_prog_msg("Attempting to connect to #{@host}:#{@port}")
+    get_menu_bar.enable(ID_CONNECT,false)
+    get_menu_bar.enable(ID_DISCONNECT,false)
+    start_client_thread
+  end
+  
+  # MyClientFrame#disconnect()
+  # This method utitilizes the closing of the socket connection, and killing
+  # any thread that may be running, and since we have no threads, we don't need
+  # the timer to be running, so we stop that as well.
+  def disconnect()
+    return if @socket.nil?
+		Thread.kill(@thread) unless @thread.nil?
+    @socket.send_packet("QUIT")
+    @socket.close()
+    @socket = nil
+    @timer.stop
+    get_menu_bar.enable(ID_CONNECT,true)
+    get_menu_bar.enable(ID_DISCONNECT,false)
+  end
+  
+  # MyClientFrame#on_disconnect()
+  # This method is ran from File > Disconnect and processes the disconnection from
+  # the server.
+  def on_disconnect()
+    disconnect()
+    append_prog_msg("You have disconnected from the server.")
+  end
+  
+  # MyClientFrame#on_name()
+  # This method is ran from File > Nickname, and processes the nickname that the
+  # client will use.
+  def on_name
+    msgbox = Wx::TextEntryDialog.new(self,"Enter the new nickname you want to be (Default: Client)",
+                                      "Change Nickname",@nick)
+    ret = msgbox.show_modal
+    if ret == Wx::ID_CANCEL
+      return
+    end
+    
+    nick = msgbox.get_value
+    nick = nick.split(" ").join("_") if nick.index(" ")
+    @socket.send_packet("NICK #{nick}") unless @socket.nil?
+    append_prog_msg("You changed nicknames from #{@nick} to #{nick}")
+    @nick = nick
+    @socket.send_packet("WHO") unless @socket.nil?
+  end
+  
+  # MyClientFrame#on_exit()
+  # This method is ran from File > Exit, and delegates the control over to
+  # MyClientFrame#on_close() to do it's checks to see if they are still connected
+  # or not.
+  def on_exit
+    self.close
+  end
+  
+  # MyClientFrame#on_close(evt)
+  # This method is ran from the OnCloseEvent, and checks to see if the client is still
+  # connected to the server.  If they are, it will confirm if they want to disconnect
+  # from the server or not.  If they don't want to disconnect, it will veto the close
+  # event.
+  def on_close(evt)
+    unless @socket.nil?
+      ret = Wx::message_box("You are still connected to the server, do you wish to disconnect?","Disconnect",Wx::YES|Wx::NO|Wx::ICON_QUESTION)
+      if ret == Wx::NO
+        evt.veto
+      else
+        disconnect()
+        Wx::get_app.exit_main_loop()
+      end
+    else
+      Wx::get_app.exit_main_loop()
+    end
+  end
+  
+  # MyClientFrame#on_text()
+  # This method is executed from when the user presses the Enter button from the
+  # input box.  It will processes it for any /commands, and run them as nesscary
+  # otherwise, it will send the data to the server.
+  def on_text
+    msg = @input.get_value
+    @input.set_value("")
+    case msg
+    when /\/connect/
+      on_connect
+    when /\/disconnect/
+      on_disconnect
+    when /\/nick/
+      on_name
+    when /\/exit/
+			self.close
+		when /\/eval/
+			evl_str = msg[5..-1]
+			append_prog_msg(self.instance_eval(evl_str).inspect)
+    when /\/me/
+      append_msg("<-- #{@nick} #{msg[4..-1]}")
+      msg = "EMOTE " + msg[4..-1]
+      @socket.send_packet(msg)
+    else
+      append_msg("<-- #{@nick} says: #{msg}")
+      msg = "MSG " + msg
+      @socket.send_packet(msg)
+    end
+  end
+  
+  # MyClientFrame#poll_connect()
+  # This method is called from within the polling thread, and will run till
+  # it either finds that the socket has been completed, and connected to a server,
+  # otherwise, it will check to see if there is an error.  If there is, then that
+  # means we weren't able to connect to the server.  This will then run the method
+  # Socket#connect() inside a rescue condition, so that we can see why we wasn't
+  # able to connect to the server.
+  def poll_connect()
+    loop do
+      @mutex.lock
+      ret = IO::select(nil,[@socket],[@socket],0.3)
+      unless ret.nil?
+				if Wx::PLATFORM == "WXMSW"
+					unless ret[2] == []
+						# We have an error
+						error = nil
+						begin
+							error = @socket.connect(Socket.sockaddr_in(@port,@host))
+						rescue => e
+							error = e
+						end
+						append_error("Error attempting to connect to #{@host}:#{@port}")
+						append_error("Message: #{e} (#{e.class})")
+						@mutex.unlock
+						@socket.close()
+						@socket = nil
+						get_menu_bar.enable(ID_CONNECT,true)
+						get_menu_bar.enable(ID_DISCONNECT,false)
+						@timer.stop()
+						Thread.kill(@thread)
+						@thread.exit
+						return
+					end
+				else # For WXGTK and WXMAC
+					# Since on WXGTK and WXMAC doesn't return the error part in ret, we need
+					# to check and see if we are connected.
+					error = nil
+					begin
+						error = @socket.connect(Socket.sockaddr_in(@port,@host))
+					rescue => e
+						error = e
+					end
+					if error.class != Fixnum && !error.nil?
+						# We're not connected!
+						append_error("Error attempting to connect to #{@host}:#{@port}")
+						append_error("Message: #{e} (#{e.class})")
+						@mutex.unlock
+						@socket.close()
+						@socket = nil
+						get_menu_bar.enable(ID_CONNECT,true)
+						get_menu_bar.enable(ID_DISCONNECT,false)
+						@timer.stop()
+						Thread.kill(@thread)
+						@thread.exit
+						return
+					end
+				end
+        append_prog_msg("Connected to #{@host}:#{@port}")
+        get_menu_bar.enable(ID_CONNECT,false)
+        get_menu_bar.enable(ID_DISCONNECT,true)
+        @socket.send_packet("CONNECT #{@nick}")
+        @socket.send_packet("WHO")
+        @mutex.unlock
+        break
+      end
+      @mutex.unlock
+    end
+  end
+  
+  # MyClientFrame#parse_message(msg)
+  # This method checks to see what message is being received from the server
+  # add display it to the user, as needed.
+  def parse_message(msg)
+    case msg
+    when /CONNECT/
+      append_msg("--> #{msg[8..-1]} has joined the chat server.")
+      #@users.insert_item(0,msg[8..-1],0)
+      add_user(msg[8..-1])
+    when /DISCONN/
+      append_msg("--> #{msg[8..-1]} has been removed from the chat server.")
+    when /CONN/
+      append_msg("<!> New connection incoming to the server.")
+    when /WHO/
+      cmd, *usrs = msg.split(" ")
+      clear_users()
+      usrs.each do |usr|
+        add_user(usr)
+      end
+    when /NICK/
+      a = msg.index_from(5," ")
+      old = msg[5..a-1]
+      new = msg[a+1..-1]
+      append_msg("--> #{old} has changed their nickname to #{new}")
+      @socket.send_packet("WHO")
+    when /MSG/
+      a = msg.index_from(4," ")
+      user = msg[4..a-1]
+      txt = msg[a+1..-1]
+      append_msg("--> #{user} says: #{txt}")
+    when /EMOTE/
+      a = msg.index_from(6," ")
+      user = msg[6..a-1]
+      txt = msg[a+1..-1]
+      append_msg("--> #{user} #{txt}")
+    when /QUIT/
+      append_msg("--> #{msg[5..-1]} is quitting the chat server.")
+      @socket.send_packet("WHO")
+    when /SHUTDOWN/
+      append_msg("--> #{msg[9..-1]}")
+    else
+      append_error("Unknown message received from the server.")
+      append_error("Message: #{msg}")
+    end
+  end
+  
+  # MyClientFrame#poll_data()
+  # This method will poll the connection for incoming data, and to see if it
+  # has been disconnected from the server or not.  It will continue to poll
+  # till a connection has been closed, either by the server, or by the user.
+  def poll_data()
+    loop do
+      @mutex.lock
+      ret = IO::select([@socket],nil,nil,0.3)
+      unless ret.nil?
+        if @socket.eof?
+          append_prog_msg("You have been disconnected from the server!")
+          get_menu_bar.enable(ID_CONNECT,true)
+          get_menu_bar.enable(ID_DISCONNECT,false)
+          @socket.close
+          @socket = nil
+          @timer.stop
+          @mutex.unlock
+					@thread.exit
+          break
+        end
+        msg = @socket.recv_packet()
+        @buffer += msg
+        loop do
+          at = @buffer.index("\n")
+          if at.nil?
+            break
+          end
+          data = @buffer[0..at-1]
+          @buffer = @buffer[at+1..-1]
+          parse_message(data)
+        end
+      end
+      @mutex.unlock
+    end
+  end
+  
+  # MyClientFrame#start_client_thread()
+  # This method will actually start the polling of a connection for the connection
+  # and data.  First it will start the polling of the connection, after it successfully
+  # receives the connection, it will start polling for incoming data.
+  def start_client_thread
+    @thread = Thread.new do
+      @timer.start(25)
+      poll_connect()
+      poll_data()
+    end
+  end
+end
+
+class MySocketApp < Wx::App
+  def on_init
+		Thread.abort_on_exception = true
+    frame = MyClientFrame.new(nil,-1,"Socket Demo >> Client")
+    frame.show
+  end
+end
+
+MySocketApp.new.main_loop