my code

package main

import (
	"encoding/json"
	"fmt"
	"gopkg.in/qml.v0"
	"log"
	"os"
	//"bufio"
	"net"

	"strings"
)

type Control struct {
	Root        qml.Object
	Convstring  string
	userlist    string
	InputString string
	User        string
}

type Message struct {
	Kind      string //type of message ("CONNECT","PRIVATE","PUBLIC","DISCONNECT","HEARTBEAT","LIST","ADD")
	Username  string //my username
	IP        string //ip address of my computer
	MSG       string //message
	UserNames [100]string
	IPs       [100]string
	Count     int
}

var (
	incoming chan string = make(chan string)
	err      error
	tcpAddr  *net.TCPAddr
	//enc         *json.Encoder
	conList      [111]net.Conn
	userList     [111]string
	count        int
	listOfUsers  string
	msg          Message
	firstConnect string
)

/*
func Send(ctrl Control) {

	//reader := bufio.NewReader(os.Stdin)
	//ctrl:=new(Control)

		for {
			//ctrl.InputString,_=reader.ReadString('\n')
			//fmt.Println(*ctrl)
			if ctrl.InputString=="" {
				conn.Close()
				fmt.Println("closed connection")
				os.Exit(0)
			}


	err := enc.Encode(ctrl)
	handleErr(err)
}
*/

func (ctrl *Control) TextEntered(text qml.Object) {
	//this method is called whenever a return key is typed in the text entry field.  The qml object calls this function
	ctrl.InputString = text.String("text") //the ctrl's inputString field holds the message
	//you will want to send it to the server
	//but for now just send it back to the conv field
	//Send(*ctrl)
	sendMessage()
	ctrl.updateText(ctrl.InputString)
}

func (ctrl *Control) updateText(toAdd string) {
	//call this method whenever you want to add text to the qml object's conv field
	ctrl.Convstring = ctrl.Convstring + toAdd + "\n" //also keep track of everything in that field
	ctrl.Root.ObjectByName("conv").Set("text", ctrl.Convstring)
	qml.Changed(ctrl, &ctrl.Convstring)
}

func (ctrl *Control) addList(name string) {
	//call this method whenever you want to change the text in the qml object's userlist field
	ctrl.userlist = ctrl.userlist + name
	ctrl.Root.ObjectByName("userlist").Set("text", name)
	qml.Changed(ctrl, &ctrl.userlist)
}

func (ctrl *Control) handleServer(dec *json.Decoder) {
	for {

		var msg Message
		dec.Decode(&msg)

		//fmt.Println(newText)

		ctrl.updateText(msg.MSG)

	}
}

func handleClients() {
	service := ":1500"
	tcpAddr, err := net.ResolveTCPAddr("tcp", service)
	handleErr(err)
	listener, err := net.ListenTCP("tcp", tcpAddr)
	handleErr(err)
	msg.Count = 0

	for {

		conn, err := listener.Accept()

		conList[msg.Count] = conn
		idNum := msg.Count
		msg.Count++
		//fmt.Println(count)
		if err != nil {
			continue
		}
		go handleClient(conn, idNum)
	}
}

func handleClient(conn net.Conn, userNum int) {
	defer conn.Close()
	dec := json.NewDecoder(conn)
	enc := json.NewEncoder(conn)
	//enc := json.NewEncoder(conn)
	var ctrl Control
	var userName string
	dec.Decode(&msg)

	msg.UserNames[userNum] = userName

	for {
		var newMsg Message
		//err:=dec.Decode(&ctrl)
		dec.Decode(&newMsg)
		msg.UserNames[userNum] = newMsg.Username
		/*
			if err != nil {
				fmt.Println("closing connection")
				return
			}
		*/
		if newMsg.Kind == "CONNECT" {
			for i := 0; i < userNum; i++ {
				if newMsg.Username == newMsg.UserNames[i] {
					enc := json.NewEncoder(conn)
					//fmt.Println(ctrl.InputString)
					msg.MSG = "you have been disconnected because of your username"
					msg.MSG = "Admin: " + msg.MSG
					enc.Encode(msg)
					return
				}
			}

			msg.IPs[userNum] = newMsg.IP
			var listOfUsers string
			for i := 0; i < count; i++ {

				listOfUsers = listOfUsers + msg.UserNames[i] + "\n"
			}
			ctrl.addList(listOfUsers)
			enc.Encode(msg)

		}
		if newMsg.Kind == "ADD"{

		}
		if newMsg.Kind == "PUBLIC" {
			ctrl.updateText(newMsg.MSG)
		}
		if ctrl.Convstring == "ivtuitvtv" {
			var tempList [111]string
			listOfUsers = ""
			for i := 0; i < msg.Count; i++ {
				if ctrl.User == userList[i] {

				} else {
					tempList[i] = userList[i]

				}
			}
			userList = tempList
			return

		}
	}
}

func sendMessage() {
	if strings.HasPrefix(msg.MSG, "CONNECT") {
		msg.Kind = "CONNECT"
		tcpAddr, err = net.ResolveTCPAddr("tcp", firstConnect)
		handleErr(err)
		conn, err := net.DialTCP("tcp", nil, tcpAddr)
		handleErr(err)
		conList[count] = conn
		count++

	} else if strings.HasPrefix(msg.MSG, "PUBLIC") {
		msg.Kind = "PUBLIC"
	}

	for i := 0; i < msg.Count; i++ {
		enc := json.NewEncoder(conList[i])
		dec := json.NewDecoder(conList[i])
		//fmt.Println(ctrl.InputString)

		msg.MSG = msg.Username + ": " + msg.MSG

		enc.Encode(msg)
		if msg.Kind == "CONNECT" {
			var newMsg Message
			dec.Decode(&newMsg)
			msg.IPs = newMsg.IPs
			msg.UserNames = newMsg.UserNames
			msg.Count = newMsg.Count
			for i := 0; i < msg.Count; i++ {
				tcpAddr, err = net.ResolveTCPAddr("tcp", msg.IPs[msg.Count])
				handleErr(err)
				conn, err := net.DialTCP("tcp", nil, tcpAddr)
				handleErr(err)
				conList[count] = conn
				count++
				enc = json.NewEncoder(conList[i])
				dec = json.NewDecoder(conList[i])
				msg.Kind = "ADD"
				enc.Encode(msg)
			}
		}
	}
}

func main() {
	msg.Username = "Nick"
	msg.IP = "172.17.9.78:1500"
	msg.IPs[0] = msg.IP
	msg.UserNames[0] = msg.Username
	firstConnect = ""
	go handleClients()

	engine := qml.NewEngine()

	ctrl := Control{Convstring: ""}
	ctrl.Convstring = ""
	context := engine.Context()
	context.SetVar("ctrl", &ctrl)

	component, err := engine.LoadFile("chat_ui2.qml")
	if err != nil {
		fmt.Println("no file to load for ui")
		fmt.Println(err.Error())
		os.Exit(0)
	}
	win := component.CreateWindow(nil)

	ctrl.Root = win.Root()

	win.Show()
	//ctrl.updateText("adding line of text to the conv field")
	//ctrl.addList("adding to list")
	//ctrl1 := Control

	win.Wait() //blocks until the window is closed

	/*
		ctrl.Convstring="ivtuitvtv"
		enc = json.NewEncoder(conn)
		err = enc.Encode(ctrl)
		handleErr(err)
	*/

}

func handleErr(err error) {
	if err != nil {
		log.Fatal(err)
	}
}