lambda/main.go

package main

import (
	"log"
	"net/http"
	_ "net/http/pprof"

	"os"
	"strings"
	"sync"

	"context"
	"crypto/tls"
	"fmt"
	"path/filepath"

	"github.com/diamondburned/gotk4/pkg/gdk/v4"
	"github.com/diamondburned/gotk4/pkg/gdkpixbuf/v2"
	"github.com/diamondburned/gotk4/pkg/gio/v2"
	"github.com/diamondburned/gotk4/pkg/glib/v2"
	"github.com/diamondburned/gotk4/pkg/gtk/v4"
	"github.com/diamondburned/gotk4/pkg/pango"
	"github.com/gen2brain/beeep"
	"github.com/go-analyze/charts"
	"github.com/google/uuid"

	"time"

	"github.com/BurntSushi/toml"
	"gosrc.io/xmpp"
	"gosrc.io/xmpp/stanza"

	_ "embed"
	"encoding/xml"
	"runtime"

	"github.com/kr/pretty"
)

var loadedConfig lambdaConfig

var empty_dialog *gtk.Image

var connectionStatus *gtk.Label
var connectionIcon *gtk.Image

var mStatus *gtk.Label
var mIcon *gtk.Image

var gStatus *gtk.Label
var gIcon *gtk.Image

var typingStatus *gtk.Label

var pingStatus *gtk.Label

var content *gtk.Widgetter

var tabs sync.Map
var current string

var scroller *gtk.ScrolledWindow
var memberList *gtk.ScrolledWindow
var menu *gtk.Box
var message_en *gtk.Entry

//go:embed style.css
var styleCSS string
var client xmpp.Sender
var clientroot *xmpp.Client

var window *gtk.ApplicationWindow

// stores members of mucs
var mucmembers sync.Map

// stores devices of users
var userdevices sync.Map

var pingTimes = [][]float64{}

var xmlLog *os.File

// Basic roster
var Roster = make(map[string]bool)

var config_filename = "lambda.toml"
var app_id = "net.sunglocto.lambda"

func init() {
	beeep.AppName = loadedLocale["appName"]
}

func main() {
	if os.Getenv("PROFILE") != "" {
		config_filename = fmt.Sprintf("lambda_%s.toml", os.Getenv("PROFILE"))
		app_id = "net.sunglocto.lambda." + os.Getenv("PROFILE")
	}

	pingTimes = append(pingTimes, []float64{})
	p, err := ensureConfig()
	if err != nil {
		panic(err)
	}

	b, err := os.ReadFile(filepath.Join(p, config_filename))
	if err != nil {
		dropToSignInPage(err)
		return
	}

	_, err = toml.Decode(string(b), &loadedConfig)
	if err != nil {
		panic(err)
	}
	if loadedConfig.Debug {
		go func() {
			log.Println(http.ListenAndServe("localhost:6060", nil))
		}()
		log.Println("pprof debug server running at port 6060")
	}

	if loadedConfig.Resource == "" {
		fmt.Println(loadedLocale["configResourceEmptyWarning"])
		loadedConfig.Resource = randomClientResource()
	}

	if !loadedConfig.Debug {
		xmlLog, err = os.CreateTemp("", "xmpp-log")
		if err != nil {
			panic(err)
		}

		defer os.Remove(xmlLog.Name())
	} else {
		xmlLog = os.Stdout
	}

	res := "/" + loadedConfig.Resource
	if loadedConfig.RandomizeResource {
		res = ""
	}

	config := xmpp.Config{
		TransportConfiguration: xmpp.TransportConfiguration{
			Address:        loadedConfig.Server,
			ConnectTimeout: 300,
			TLSConfig:      &tls.Config{InsecureSkipVerify: loadedConfig.Insecure},
		},
		Jid:                    loadedConfig.Username + res,
		Credential:             xmpp.Password(loadedConfig.Password),
		Insecure:               loadedConfig.Insecure,
		StreamManagementEnable: true,
		ConnectTimeout:         300,
		StreamLogger:           xmlLog,
	}
	router := xmpp.NewRouter()

	router.NewRoute().IQNamespaces(stanza.NSDiscoInfo).HandlerFunc(func(s xmpp.Sender, p stanza.Packet) {
		iq, ok := p.(*stanza.IQ)
		if !ok || iq.Type != stanza.IQTypeGet {
			return
		}

		iqResp, err := stanza.NewIQ(stanza.Attrs{Type: "result", From: iq.To, To: iq.From, Id: iq.Id})
		if err != nil {
			panic(err)
		}

		// All requests from either ourselves or our server will always be accepted regardless of user settings.

		if !(loadedConfig.DiscoPrivacy == 0) && !((JidMustParse(iq.From).Bare() == JidMustParse(clientroot.Session.BindJid).Bare()) || (JidMustParse(iq.From).Domain == JidMustParse(clientroot.Session.BindJid).Domain)) {
			if loadedConfig.DiscoPrivacy == None || (loadedConfig.DiscoPrivacy == OnlyRoster && !Roster[JidMustParse(iq.From).Bare()]) {
				if loadedConfig.IgnoreInsteadOfReturnErrorUponPrivacyViolation {
					return
				}

				iqResp.Type = "error"
				iqResp.From = clientroot.Session.BindJid
				iqResp.Id = iq.Id

				stanza_err := new(stanza.Err)
				stanza_err.Type = stanza.ErrorTypeCancel
				stanza_err.Text = "service-unavailable"

				iqResp.MakeError(*stanza_err)
				s.Send(iqResp)
				return
			}
		}

		identity := stanza.Identity{
			Name:     "Lambda",
			Category: "client", // TODO: Allow spoofing on user request
			Type:     "pc",
		}
		payload := stanza.DiscoInfo{
			XMLName: xml.Name{
				Space: stanza.NSDiscoInfo,
				Local: "query",
			},
			Identity: []stanza.Identity{identity},
			Features: []stanza.Feature{
				{Var: stanza.NSDiscoInfo},
				{Var: stanza.NSDiscoItems},
				{Var: "jabber:iq:version"},
				{Var: "urn:xmpp:delegation:1"},
				{Var: "http://jabber.org/protocol/muc"},
				{Var: "λ"},
				{Var: "urn:xmpp:attention:0"},
				{Var: "urn:xmpp:carbons:2"},
				{Var: "urn:xmpp:ping"},
				{Var: "jabber:iq:oob"},
				{Var: "jabber:x:oob"},
				{Var: "jabber:x:data"},
			},
		}
		iqResp.Payload = &payload
		s.Send(iqResp)
	})

	router.NewRoute().IQNamespaces("jabber:iq:version").HandlerFunc(func(s xmpp.Sender, p stanza.Packet) {
		iq, ok := p.(*stanza.IQ)
		if !ok || iq.Type != stanza.IQTypeGet {
			return
		}

		iqResp, err := stanza.NewIQ(stanza.Attrs{Type: "result", From: iq.To, To: iq.From, Id: iq.Id})
		if err != nil {
			panic(err)
		}

		// All requests from either ourselves or our server will always be accepted regardless of user settings.

		if !(loadedConfig.VersionPrivacy == 0) && !((JidMustParse(iq.From).Bare() == JidMustParse(clientroot.Session.BindJid).Bare()) || (JidMustParse(iq.From).Domain == JidMustParse(clientroot.Session.BindJid).Domain)) {
			if loadedConfig.VersionPrivacy == None || (loadedConfig.VersionPrivacy == OnlyRoster && !Roster[JidMustParse(iq.From).Bare()]) {
				if loadedConfig.IgnoreInsteadOfReturnErrorUponPrivacyViolation {
					return
				}

				iqResp.Type = "error"
				iqResp.From = clientroot.Session.BindJid
				iqResp.Id = iq.Id

				stanza_err := new(stanza.Err)
				stanza_err.Type = stanza.ErrorTypeCancel
				stanza_err.Text = "service-unavailable"

				iqResp.MakeError(*stanza_err)
				s.Send(iqResp)
				return
			}
		}

		v := &stanza.Version{}
		v = v.SetInfo(loadedLocale["appName"], lambda_version, runtime.GOOS) // TODO: Allow spoofing on user request

		iqResp.Payload = v
		s.Send(iqResp)
	})

	router.HandleFunc("message", func(s xmpp.Sender, p stanza.Packet) {
		var blocked bool
		m, ok := p.(stanza.Message)
		if !ok {
			return
		}

		originator := JidMustParse(m.From).Bare()
		var typed_tab *chatTab
		tab, ok := tabs.Load(originator)
		if ok {
			typed_tab = tab.(*chatTab)
		} else {

			if m.Type != stanza.MessageTypeGroupchat {
				createTab(originator, false, originator)
				tab, ok = tabs.Load(originator)
				if ok {
					typed_tab = tab.(*chatTab)
					glib.IdleAdd(func() {
						box := createTabBox(originator, originator, originator, true)
						menu.Append(box)
						menu.Append(gtk.NewSeparator(gtk.OrientationVertical))
					})
				} else {
					return
				}
			} else {
				return
			}
		}

		oi := new(OccupantID)
		ok = m.Get(oi)
		if ok {
			id := oi.ID
			va, ok := loadedConfig.BlockingOI[id]
			if ok {
				if va {
					if loadedConfig.BlockingMode == Drop {
						return
					} else {
						blocked = true
					}
				}
			}
		}

		sid := new(StanzaID)
		m.Get(sid)

		at := new(Attention)
		ok = m.Get(at)
		if ok {
			beeep.Notify(loadedLocale["attention"], fmt.Sprintf("%s: %s", JidMustParse(m.From).Resource, m.Body), commentBytes) // TODO: Use localpart if DM
		}

		// Handle mentions
		for _, ext := range m.Extensions {
			mention, ok := ext.(*Mention)
			if ok {
				pretty.Println(mention)
			}

		}

		sc := new(SentCarbon)
		ok = m.Get(sc)
		if ok {
			fm, ok := sc.Forwarded.Stanza.(stanza.Message)
			if ok {
				if JidMustParse(fm.From).Bare() == JidMustParse(m.From).Bare() {
					p = sc.Forwarded.Stanza
					orig := m.To
					m = sc.Forwarded.Stanza.(stanza.Message)
					m.To = orig
				} else {
					panic(fmt.Sprintln("Impersonation: ", fm.From, m.From))
				}
			}
		}

		rc := new(SentCarbon)
		ok = m.Get(rc)
		if ok {
			fm, ok := rc.Forwarded.Stanza.(stanza.Message)
			if ok {
				if JidMustParse(fm.From).Bare() == JidMustParse(m.From).Bare() {
					p = rc.Forwarded.Stanza
					m = rc.Forwarded.Stanza.(stanza.Message)
				} else {
					panic(fmt.Sprintln("Impersonation: ", fm.From, m.From))
				}
			}
		}
		composing := stanza.StateComposing{}
		ok = m.Get(&composing)
		if ok && current == JidMustParse(m.From).Bare() {
			typingStatus.SetText(fmt.Sprintf("%s%s", m.From, loadedLocale["isTyping"]))
			return
		}

		inactive := stanza.StateInactive{}
		ok = m.Get(&inactive)
		if ok && current == JidMustParse(m.From).Bare() {
			typingStatus.SetText("")
			return
		}

		// Handle read indicators
		marker := new(Marker)
		ok = m.Get(marker)
		if ok && !loadedConfig.CompactMode {
			_, ok := typed_tab.msg_refsOSID.Load(marker.ID)
			if ok {
				im := gtk.NewImage()
				im.SetPixelSize(20)
				im.SetTooltipText(JidMustParse(m.From).Resource)
				glib.IdleAdd(func() {
					createIdenticon(m.From, false, im)
				})

				pres, err := getPresenceFromJIDMuc(JidMustParse(m.From))
				if err != nil {
					return
				}

				var vu VCardUpdate
				ok = pres.Get(&vu)
				if ok {
					go getAvatar(m.From, vu.Photo, im)
				}

				uind, loaded := typed_tab.msg_refsOSID.Load(marker.ID)
				if loaded {
					ind, ok := uind.(*abMessage)
					if ok {
						if ind.read_indicator != nil {
							ind.read_indicator.Append(im)
						}
					}
				}
				return
			}
			return
		}

		// Handle corrections BEFORE attempting to generate a message
		correction := new(Correction)
		ok = m.Get(correction)
		if ok {
			tab, ok := tabs.Load(originator)
			if ok {
				typed_tab := tab.(*chatTab)
				if ok {
					msg, ok := typed_tab.msg_refsID[correction.ID]
					if ok {
						if msg.ocu_id == oi.ID && msg.ocu_id != "" {
							lab := msg.label_ref
							if lab != nil {
								glib.IdleAdd(func() {
									lab.SetMarkup(XEPToPango(m.Body, true))
								})
							}
						}
						return
					}
				}
			}
		}

		// The same, however with retractions
		retraction := new(Retraction)
		ok = m.Get(retraction)
		if ok {
			tab, ok := tabs.Load(originator)
			if ok {
				typed_tab := tab.(*chatTab)
				umsg, ok := typed_tab.msg_refsOSID.Load(retraction.ID)
				if ok {
					msg, ok := umsg.(*abMessage)
					if ok {
						lab := msg.label_ref
						glib.IdleAdd(func() {
							GenerateRetraction(lab, *retraction)
						})
						return
					}
				}
			}
		}

		glib.IdleAddPriority(glib.PriorityLow, func() {
			b := gtk.NewBox(gtk.OrientationVertical, 0)

			tab, ok := tabs.Load(originator)
			if !ok {
				return
			}

			typed_tab, ok := tab.(*chatTab)
			if !ok {
				return
			}

			if ok {
				if current == JidMustParse(m.From).Bare() {
					scrollToBottomAfterUpdate(scroller)
				}
			} else {
				fmt.Println("Got message when the tab does not exist!")
			}

			untyped_box, valid := generateMessageWidget(p, blocked, originator)
			ba, converted_successfully := untyped_box.(*gtk.Box)

			if valid && converted_successfully {
				mStatus.SetText(originator)
				if typed_tab.msgs != nil {
					typed_tab.msgs.Append(b)
					b.Append(ba)
					b.Append(gtk.NewSeparator(gtk.OrientationVertical))
				}
			}
		})
	})

	router.HandleFunc("presence", func(s xmpp.Sender, p stanza.Packet) {
		presence, ok := p.(stanza.Presence)
		if !ok {
			return
		}

		if presence.Error.Reason != "" {
			// beeep.Notify(fmt.Sprintf("%s : %s", presence.From, presence.Error.Reason), presence.Error.Text, cancelBytes)
			return
		}

		var mu MucUser
		var ocu OccupantID

		ok = presence.Get(&mu)

		if ok { // This is a presence stanza from a user in a MUC
			from_self, created := false, false
			for _, status := range mu.StatusCodes {
				if status.Code == "110" {
					from_self = true
				}

				if status.Code == "201" {
					created = true
				}
			}

			if from_self && created {
				showDialog("You have created a new MUC. In order for people to be able to join this MUC, you must first configure it. You can configure this MUC by clicking on the MUC button in the top right and then clicking 'Configre MUC'.", &window.Window)
			}

			presence.Get(&ocu)
			id := JidMustParse(presence.From).Resource
			from, _ := stanza.NewJid(presence.From)
			muc := from.Bare()
			_, ok = mucmembers.Load(muc)
			if !ok && presence.Type != "unavailable" {
				mucmembers.Store(muc, mucUnit{})
			}

			unit, ok := mucmembers.Load(muc)
			if !ok {
				return
			}

			typed_unit := unit.(mucUnit)

			if mu.MucUserItem.JID == clientroot.Session.BindJid {
				tab, ok := tabs.Load(muc)
				if ok {
					typed_tab := tab.(*chatTab)
					typed_tab.current_nick = id
				}
			}

			if presence.Type != "unavailable" {
				_, ok := typed_unit.Members.Load(id)
				if !ok && loadedConfig.ShowPresenceUpdates {
					glib.IdleAddPriority(glib.PriorityLow, func() {
						b := gtk.NewBox(gtk.OrientationVertical, 0)
						ba, ok := generatePresenceWidget(p).(*gtk.Box)
						if ok {
							b = ba
						}

						tab, ok := tabs.Load(muc)
						typed_tab, ok2 := tab.(*chatTab)

						if ok && ok2 {
							typed_tab.msgs.Append(b)
							if current == muc {
								scrollToBottomAfterUpdate(scroller)
							}
						} else {
							fmt.Println("Got message when the tab does not exist!")
						}
					})
				}
				typed_unit.Members.Store(id, presence)
			} else {
				typed_unit.Members.Delete(id)
				if loadedConfig.ShowPresenceUpdates {
					glib.IdleAddPriority(glib.PriorityLow, func() {
						b := gtk.NewBox(gtk.OrientationVertical, 0)
						ba, ok := generatePresenceWidget(p).(*gtk.Box)
						if ok {
							b = ba
						}

						tab, ok := tabs.Load(muc)
						typed_tab := tab.(*chatTab)

						if ok {
							b.Append(gtk.NewSeparator(gtk.OrientationVertical))
							typed_tab.msgs.Append(b)
							if current == muc {
								scrollToBottomAfterUpdate(scroller)
							}
						} else {
							fmt.Println("Got message when the tab does not exist!")
						}
					})
				}
			}

			mucmembers.Store(muc, typed_unit)

		} else { // This is a presence stanza from a regular user
			// The code is basically the exact same as above, we just don't check for mucuser

			// TODO: Presence handling code goes here
			j := presence.From
			tab, ok := tabs.Load(j)
			if ok {
				typed_tab, ok := tab.(*chatTab)
				if ok {
					if typed_tab.isMuc {
						typed_tab.muc_presence = &presence
					}
				}
			}
		}
	})

	c, err := xmpp.NewClient(&config, router, func(err error) {
		connectionStatus.SetText(fmt.Sprintf("%s%s", loadedLocale["disconnected"], err.Error()))
		connectionIcon.SetFromPaintable(clientAssetsLoad("disconnect"))
	})

	if err != nil {
		showErrorDialog(err, &window.Window)
		panic(err)
	}
	client = c
	clientroot = c

	cm := xmpp.NewStreamManager(c, func(c xmpp.Sender) {
		fmt.Println("XMPP client connected")
		client = c
		// clientroot = c

		go func() {
			for {
				time.Sleep(5 * time.Second)
				go func() {
					// Goroutine counter
					goroutines := runtime.NumGoroutine()
					glib.IdleAdd(func() {
						gStatus.SetText(fmt.Sprintf("%d goroutines", goroutines))
					})
				}()

				go func() {
					// Ping
					pingStatus.AddCSSClass("pending")
					before := time.Now()
					iq := new(stanza.IQ)
					iq.Id = uuid.NewString()
					iq.From = clientroot.Session.BindJid
					iq.Type = "get"
					iq.Payload = &Ping{}

					ctx, _ := context.WithTimeout(context.Background(), 30*time.Second)
					mychan, err := client.SendIQ(ctx, iq)
					if err != nil {
						return
					}
					_ = <-mychan
					delay := time.Since(before) / time.Millisecond
					pingTimes[0] = append(pingTimes[0], float64(delay))

					glib.IdleAdd(func() {
						pingStatus.RemoveCSSClass("pending")
						pingStatus.SetText(fmt.Sprintf("%d %s", delay, loadedLocale["milliseconds"]))
					})
				}()

			}
		}()

		glib.IdleAdd(func() {
			connectionStatus.SetText(fmt.Sprintf("%s%s", loadedLocale["connectedAs"], JidMustParse(clientroot.Session.BindJid).Bare()))
			connectionStatus.SetTooltipText(fmt.Sprintf("%s%s\n%s%t", loadedLocale["bindedJid"], clientroot.Session.BindJid, loadedLocale["usingTLS"], clientroot.Session.TlsEnabled))
			connectionIcon.SetFromPaintable(clientAssetsLoad("connect"))

			if loadedConfig.CheckUpdate == "" {
				showInitialConsent()
			}

			if loadedConfig.CheckUpdate == "yes" {
				err := updateCheck()
				if err != nil {
					showErrorDialog(err, &window.Window)
				}
			}
		})
		// Enable carbons
		client.SendRaw(fmt.Sprintf(
			`<iq xmlns='jabber:client'
				from='%s'
				id='enable1'
				type='set'>
			  <enable xmlns='urn:xmpp:carbons:2'/>
			</iq>
		`, clientroot.Session.BindJid))

		// Create note to self
		jid := JidMustParse(clientroot.Session.BindJid).Bare()
		name := "Note To Self"
		createTab(jid, false, name)
		glib.IdleAdd(func() {
			b := createTabBox(name, jid, jid, false)
			menu.Append(b)
			menu.Append(gtk.NewSeparator(gtk.OrientationHorizontal))
		})

		// Fetch roster
		i, err := stanza.NewIQ(stanza.Attrs{
			Type: "get",
		})
		if err != nil {
			panic(err)
		}

		roster := i.RosterItems()
		i.Payload = roster
		mychan, err := c.SendIQ(context.TODO(), i)
		result := <-mychan
		if err == nil {
			items, ok := result.Payload.(*stanza.RosterItems)
			if ok {
				for _, v := range items.Items {
					name := v.Name
					jid := v.Jid
					Roster[jid] = true

					if name == "" {
						name = jid
					}

					createTab(jid, false, name)
					glib.IdleAdd(func() {
						box := createTabBox(name, jid, jid, false)
						menu.Append(box)
						menu.Append(gtk.NewSeparator(gtk.OrientationHorizontal))
					})
				}
			}
		}

		// Join rooms in bookmarks
		if loadedConfig.JoinBookmarks {
			books, err := stanza.NewItemsRequest("", "urn:xmpp:bookmarks:1", 0)
			if err == nil {
				mychan, err := c.SendIQ(context.TODO(), books)
				result := <-mychan
				if err == nil {
					res, ok := result.Payload.(*stanza.PubSubGeneric)
					if ok {
						fmt.Printf("%d rooms in bookmarks\n", len(res.Items.List))
						for _, item := range res.Items.List {
							jid := item.Id
							node := item.Any
							autojoin := false
							name := jid
							password := ""
							nick := loadedConfig.Nick
							for _, attr := range node.Attrs {
								if attr.Name.Local == "autojoin" {
									autojoin = attr.Value == "true"
									break
								}
							}

							for _, attr := range node.Attrs {
								if attr.Name.Local == "name" {
									name = attr.Value
									break
								}
							}

							for _, attr := range node.Attrs {
								if attr.Name.Local == "autojoin" {
									autojoin = attr.Value == "true"
									break
								}
							}

							for _, node := range node.Nodes {
								if node.XMLName.Local == "nick" {
									nick = node.Content
									break
								}
							}

							for _, node := range node.Nodes {
								if node.XMLName.Local == "password" {
									password = node.Content
									break
								}
							}

							_, ok := tabs.Load(jid)
							if !ok && autojoin {
								joinMuc(client, clientroot.Session.BindJid, jid, nick, password)
								createTab(jid, true, name)
								glib.IdleAdd(func() {
									box := createTabBox(name, jid, jid, true)
									menu.Append(box)
									menu.Append(gtk.NewSeparator(gtk.OrientationHorizontal))
								})
							}

						}
					}

				}
			}

			// Local bookmarks
			for jid, nick := range loadedConfig.LocalBookmarks {
				joinMuc(client, clientroot.Session.BindJid, jid, nick, "")
				createTab(jid, true, jid)
				glib.IdleAdd(func() {
					box := createTabBox(jid, jid, jid, true)
					menu.Append(box)
					menu.Append(gtk.NewSeparator(gtk.OrientationHorizontal))
				})
			}
		}
	})

	conc := func() {
		connectionStatus.SetText(loadedLocale["connecting"])
		connectionIcon.SetFromPaintable(clientAssetsLoad("hourglass"))

		err = cm.Run()
		if err != nil {
			fmt.Println(err.Error())
			connectionStatus.SetText(fmt.Sprintf("%s%s", loadedLocale["disconnected"], err.Error()))
			connectionIcon.SetFromPaintable(clientAssetsLoad("disconnect"))
		}
	}

	app := gtk.NewApplication(app_id, gio.ApplicationDefaultFlags)
	app.ConnectActivate(func() {
		activate(app)
		go conc()
	})

	if code := app.Run(os.Args); code > 0 {
		os.Exit(code)
	}
}

func activate(app *gtk.Application) {
	// Load the CSS and apply it globally.
	gtk.StyleContextAddProviderForDisplay(
		gdk.DisplayGetDefault(), loadCSS(styleCSS),
		gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
	)

	window = gtk.NewApplicationWindow(app)
	the_menu := gio.NewMenu()

	fileMenu := gio.NewMenu()
	fileMenu.Append(loadedLocale["joinMUCMenu"], "app.join")
	fileMenu.Append(loadedLocale["destroyMUCMenu"], "app.destroymuc")
	fileMenu.Append("MUC Affiliations", "app.mucaffils")
	fileMenu.Append("Configure MUC", "app.configuremuc")

	viewAffilsMucAction := gio.NewSimpleAction("mucaffils", nil)
	viewAffilsMucAction.ConnectActivate(func(p *glib.Variant) {
		go func() {
			cur, ok := tabs.Load(current)
			if ok {
				cur := cur.(*chatTab)
				if cur.isMuc {
					affils := []string{"owner", "admin", "member", "outcast"}
					items := []MucAdminItem{}

					for _, affil := range affils {
						iq, err := stanza.NewIQ(stanza.Attrs{Type: stanza.IQTypeGet, To: current, Id: uuid.NewString(), From: clientroot.Session.BindJid})
						if err != nil {
							return
						}

						q := new(MucAdminQuery)
						q.MucAdminItems = append(q.MucAdminItems, MucAdminItem{Affiliation: affil})
						iq.Payload = q
						ctx := context.TODO()
						mychan, err := client.SendIQ(ctx, iq)

						result := <-mychan
						res, ok := result.Payload.(*MucAdminQuery)
						if ok {
							for _, item := range res.MucAdminItems {
								items = append(items, item)
							}
						}
					}

					glib.IdleAdd(func() {
						affil_win := gtk.NewWindow()
						affil_box := gtk.NewBox(gtk.OrientationVertical, 2)
						affil_box.Append(gtk.NewLabel("Affiliations"))

						scroller := gtk.NewScrolledWindow()
						scroller_grid := gtk.NewGrid()
						scroller_grid.SetVExpand(true)
						scroller.SetChild(scroller_grid)
						scroller.SetVExpand(true)

						affil_box.Append(scroller)

						affil_win.SetChild(affil_box)
						scroller_grid.Attach(gtk.NewLabel("Affiliation"), 0, 0, 1, 1)
						scroller_grid.Attach(gtk.NewLabel("JID"), 1, 0, 1, 1)
						scroller_grid.Attach(gtk.NewLabel("Nick"), 2, 0, 1, 1)
						scroller_grid.Attach(gtk.NewLabel("Reason"), 3, 0, 1, 1)

						for i, v := range items {
							medal_box := gtk.NewBox(gtk.OrientationHorizontal, 0)
							medal_box.Append(gtk.NewImageFromPaintable(clientAssetsLoad(v.Affiliation)))
							medal_box.Append(gtk.NewLabel(v.Affiliation))
							scroller_grid.Attach(medal_box, 0, i+1, 1, 1)

							jid := gtk.NewLabel(v.JID)
							jid.AddCSSClass("jid")
							jid.SetSelectable(true)
							scroller_grid.Attach(jid, 1, i+1, 1, 1)

							nick := gtk.NewLabel(v.Nick)
							nick.SetSelectable(true)
							scroller_grid.Attach(nick, 2, i+1, 1, 1)

							reason := gtk.NewLabel(v.Reason)
							reason.SetSelectable(true)
							reason.SetEllipsize(pango.EllipsizeEnd)
							scroller_grid.Attach(reason, 3, i+1, 1, 1)
						}

						affil_win.SetVisible(true)
					})
				}
			}
		}()
	})

	dmMenu := gio.NewMenu()
	dmMenu.Append(loadedLocale["startDMMenu"], "app.dm")
	startDmAction := gio.NewSimpleAction("dm", nil)
	startDmAction.ConnectActivate(func(p *glib.Variant) {
		mainBox := gtk.NewBox(gtk.OrientationVertical, 5)
		dm_window := gtk.NewWindow()
		dm_window.SetTransientFor(&window.Window)
		dm_window.SetTitle("Start a DM")
		jid_box := gtk.NewBox(gtk.OrientationHorizontal, 10)
		jid_entry := gtk.NewEntry()
		create_jid := gtk.NewImageFromPaintable(clientAssetsLoad("jabber"))
		gesture := gtk.NewGestureClick()
		gesture.SetButton(1)
		gesture.Connect("pressed", func() {
			jidBuilder(jid_entry)
		})
		create_jid.AddController(gesture)

		jid_box.Append(gtk.NewLabel("JID: "))
		jid_box.Append(create_jid)
		jid_box.Append(jid_entry)

		mainBox.Append(jid_box)

		submit := gtk.NewButtonWithLabel(loadedLocale["submit"])
		submit.ConnectClicked(func() {
			t := jid_entry.Text()
			createTab(t, false, t)
			box := createTabBox(t, t, t, true)
			menu.Append(box)
			menu.Append(gtk.NewSeparator(gtk.OrientationHorizontal))
			dm_window.SetVisible(false)
		})
		mainBox.Append(submit)

		dm_window.SetChild(mainBox)
		dm_window.SetDefaultSize(100, 1)
		dm_window.SetVisible(true)
	})

	helpMenu := gio.NewMenu()
	helpMenu.Append("About", "app.about")

	aboutAction := gio.NewSimpleAction("about", nil)
	aboutAction.ConnectActivate(func(p *glib.Variant) {
		a := gtk.NewAboutDialog()
		about_window := gtk.NewWindow()
		about_window.SetTransientFor(&window.Window)
		about_window.SetTitle(fmt.Sprintf("%s %s", "About", loadedLocale["appName"]))
		a.SetProgramName(loadedLocale["appName"])
		a.SetVersion(fmt.Sprintf("Version %s", lambda_version))
		a.SetComments("yet another XMPP client")
		a.SetAuthors([]string{"Sunglocto", "Hydrogen", "Kuyuhi"})
		a.SetLicenseType(gtk.LicenseGPL30)
		a.SetLogo(clientAssetsLoad("logo"))
		a.SetWebsite("https://sunglocto.net/lambda")
		a.SetWebsiteLabel("Website")

		a.SetVisible(true)
	})

	configureMucAction := gio.NewSimpleAction("configuremuc", nil)
	configureMucAction.ConnectActivate(func(p *glib.Variant) {
		go func() {
			cur, ok := tabs.Load(current)
			if ok {
				cur := cur.(*chatTab)
				if cur.isMuc {
					iq, err := stanza.NewIQ(stanza.Attrs{
						Type: stanza.IQTypeGet,
						Id:   uuid.NewString(),
						To:   current,
					})

					if err != nil {
						glib.IdleAdd(func() { showErrorDialog(err, &window.Window) })
						return
					}

					iq.Payload = &MucOwnerQuery{}

					ctx := context.TODO()
					mychan, err := client.SendIQ(ctx, iq)
					if err != nil {
						glib.IdleAdd(func() { showErrorDialog(err, &window.Window) })
						return
					}

					result := <-mychan
					res, ok := result.Payload.(*MucOwnerQuery)

					if !ok {
						return
					}

					glib.IdleAdd(func() {
						f, win, _ := showFormDialog(res.Form)
						win.ConnectCloseRequest(func() (ok bool) {
							go func() {
								iq, err := stanza.NewIQ(stanza.Attrs{
									Id:   result.Id,
									To:   result.From,
									Type: stanza.IQTypeSet,
								})
								if err != nil {
									glib.IdleAdd(func() { showErrorDialog(err, &window.Window) })
									return
								}

								f.Type = "submit"
								mo := new(MucOwnerQuery)
								mo.Form = *f

								iq.Payload = mo

								ctx := context.TODO()
								_, err = client.SendIQ(ctx, iq)
								if err != nil {
									glib.IdleAdd(func() { showErrorDialog(err, &window.Window) })
									return
								}
							}()
							return false
						})
					})
				}
			}
		}()
	})

	destroymucAction := gio.NewSimpleAction("destroymuc", nil)
	destroymucAction.ConnectActivate(func(p *glib.Variant) {
		cur, ok := tabs.Load(current)
		if ok {
			cur := cur.(*chatTab)
			if cur.isMuc {
				win := gtk.NewWindow()
				win.SetTitle(loadedLocale["destroyMUCMenu"])
				win.SetDefaultSize(400, 1)
				win.SetResizable(false)

				box := gtk.NewBox(gtk.OrientationVertical, 10)
				box.Append(gtk.NewLabel(loadedLocale["destroyMUCWarningOne"]))
				box.Append(gtk.NewLabel(loadedLocale["destroyMUCWarningTwo"]))
				cancel := gtk.NewButtonWithLabel(loadedLocale["cancel"])
				cancel.ConnectClicked(func() {
					win.SetVisible(false)
				})
				en := gtk.NewEntry()
				en.SetPlaceholderText("...")

				submit := gtk.NewButtonWithLabel(loadedLocale["destroyMUCActionButton"])
				submit.ConnectClicked(func() {
					if en.Text() == loadedLocale["destroyMUCPassword"] {
						cur, ok := tabs.Load(current)
						if ok {
							cur := cur.(*chatTab)
							if cur.isMuc {
								client.SendRaw(fmt.Sprintf(`
				<iq from='%s'
				id='begone'
				to='%s'
				type='set'>
				<query xmlns='http://jabber.org/protocol/muc#owner'>
				<destroy jid='%s'>
				<reason>%s</reason>
				</destroy>
				</query>
				</iq>
				`, clientroot.Session.BindJid, current, JidMustParse(clientroot.Session.BindJid).Bare(), loadedLocale["userRequested"]))
							}
						}
						win.SetVisible(false)
					}
				})

				box.Append(en)
				box.Append(submit)
				box.Append(cancel)

				mu, ok := mucmembers.Load(current)
				if ok {
					typed_mu := mu.(mucUnit)
					typed_mu.Members.Range(func(k, v any) bool {
						user, ok := v.(stanza.Presence)
						if ok {
							mu := MucUser{}
							ok := user.Get(&mu)
							if ok {
								if mu.MucUserItem.JID != "" {
									if JidMustParse(mu.MucUserItem.JID).Bare() == JidMustParse(clientroot.Session.BindJid).Bare() {
										if mu.MucUserItem.Affiliation != "owner" {
											box.Append(gtk.NewLabel(loadedLocale["destroyMUCNotOwnerWarning"]))
											return false
										}
									}
								}
							}
						}
						return true
					})
				}

				win.SetChild(box)
				win.SetVisible(true)
			}
		}

	})

	joinAction := gio.NewSimpleAction("join", nil)
	joinAction.ConnectActivate(func(p *glib.Variant) {
		box := gtk.NewBox(gtk.OrientationVertical, 10)
		jid_box := gtk.NewBox(gtk.OrientationHorizontal, 10)
		nick_box := gtk.NewBox(gtk.OrientationHorizontal, 10)
		disco_box := gtk.NewBox(gtk.OrientationHorizontal, 10)
		bookmark_box := gtk.NewBox(gtk.OrientationHorizontal, 10)

		jid_entry := gtk.NewEntry()
		nick_entry := gtk.NewEntry()
		disco_check := gtk.NewCheckButton()
		bookmark_check := gtk.NewCheckButton()

		jid_entry.SetHAlign(gtk.AlignEnd)
		jid_entry.SetHExpand(true)

		nick_entry.SetHAlign(gtk.AlignEnd)
		nick_entry.SetHExpand(true)

		nick_entry.SetText(loadedConfig.Nick)

		create_jid := gtk.NewImageFromPaintable(clientAssetsLoad("jabber"))
		gesture := gtk.NewGestureClick()
		gesture.SetButton(1)
		gesture.Connect("pressed", func() {
			jidBuilder(jid_entry)
		})
		create_jid.AddController(gesture)

		jid_box.Append(gtk.NewLabel(loadedLocale["joinMUCJIDEntry"]))
		jid_box.Append(create_jid)
		jid_box.Append(jid_entry)

		nick_box.Append(gtk.NewLabel(loadedLocale["joinMUCNickEntry"]))
		nick_box.Append(nick_entry)

		disco_check.SetActive(true)
		disco_box.Append(gtk.NewLabel(loadedLocale["joinMUCDiscoCheck"]))
		disco_box.Append(disco_check)
		disco_box.SetTooltipText(loadedLocale["joinMUCDiscoCheckTooltip"])

		bookmark_check.SetActive(true)
		bookmark_box.Append(gtk.NewLabel(loadedLocale["joinMUCBookmarkCheck"]))
		bookmark_box.Append(bookmark_check)

		box.Append(jid_box)
		box.Append(nick_box)
		box.Append(disco_box)
		box.Append(bookmark_box)

		btn := gtk.NewButtonWithLabel(loadedLocale["submit"])
		btn.SetVAlign(gtk.AlignBaselineFill)

		box.Append(btn)

		win := gtk.NewWindow()
		win.SetTitle(loadedLocale["joinMUCMenu"])
		win.SetDefaultSize(400, 1)
		win.SetResizable(false)
		win.SetChild(box)

		btn.ConnectClicked(func() {
			t := jid_entry.Text()
			_, ok := tabs.Load(t)
			jm := func(n string, pw string) {
				err := joinMuc(client, clientroot.Session.BindJid, t, nick_entry.Text(), pw)
				if err != nil {
					showErrorDialog(err, win)
					return
				}

				createTab(t, true, n)
				box := createTabBox(n, t, t, true)
				menu.Append(box)
				menu.Append(gtk.NewSeparator(gtk.OrientationHorizontal))

				if bookmark_check.Active() {
					_, err := addPEPBookmark(client, t, n, nick_entry.Text(), true, pw)
					if err != nil {
						panic(err)
					}
				}
			}
			if !ok {
				if !disco_check.Active() {
					jm(t, "")
					win.SetVisible(false)
					return
				}

				var res *stanza.DiscoInfo
				allowed := true

				myIQ, err := stanza.NewIQ(stanza.Attrs{
					Type: "get",
					From: clientroot.Session.BindJid,
					To:   t,
					Id:   uuid.NewString(),
					Lang: "en",
				})

				if err != nil {
					panic(err)
				}

				myIQ.Payload = &stanza.DiscoInfo{}

				ctx := context.Background()

				var mychan chan stanza.IQ
				//go func() {
				mychan, err = client.SendIQ(ctx, myIQ)
				if err != nil {
					showErrorDialog(err, &window.Window)
				}
				//}()

				result := <-mychan
				res, ok = result.Payload.(*stanza.DiscoInfo)
				if ok {
					if len(res.Identity) >= 1 {
						features := res.Features
						allowed = false
						password_protected := false
						password := ""
						warning_win := gtk.NewWindow()
						warning_win.SetTitle(fmt.Sprintf("%s%s", loadedLocale["joinPreviewTitle"], res.Identity[0].Name))
						warning_win.SetDefaultSize(400, 1)
						warning_win.SetResizable(false)

						buttons := gtk.NewBox(gtk.OrientationHorizontal, 10)

						join_button := gtk.NewButtonWithLabel("Join")
						join_button.ConnectClicked(func() {
							warning_win.SetVisible(false)
							if password_protected {
								allowed = false

								password_win := gtk.NewWindow()
								password_win.SetTitle(loadedLocale["joinPasswordRequired"])
								password_win.SetDefaultSize(400, 1)
								password_win.SetResizable(false)
								box := gtk.NewBox(gtk.OrientationVertical, 10)
								en := gtk.NewPasswordEntry()
								submit := gtk.NewButtonWithLabel(loadedLocale["submit"])
								submit.ConnectClicked(func() {
									password = en.Text()
									jm(res.Identity[0].Name, password)
									password_win.SetVisible(false)
								})
								box.Append(en)
								box.Append(submit)
								password_win.SetChild(box)
								password_win.SetVisible(true)
							}

							jm(res.Identity[0].Name, password)
						})

						cancel_button := gtk.NewButtonWithLabel(loadedLocale["cancel"])
						cancel_button.ConnectClicked(func() {
							warning_win.SetVisible(false)
						})

						join_button.SetHExpand(true)
						cancel_button.SetHExpand(true)

						buttons.Append(join_button)
						buttons.Append(cancel_button)
						warning_box := gtk.NewBox(gtk.OrientationVertical, 10)
						header := gtk.NewLabel(res.Identity[0].Name)
						warning_box.Append(header)
						addFeature := func(icon string, description string) {
							box := gtk.NewBox(gtk.OrientationHorizontal, 10)
							box.Append(gtk.NewImageFromPaintable(clientAssetsLoad(icon)))
							box.Append(gtk.NewLabel(description))
							warning_box.Append(box)
						}

						for _, feature := range features {
							switch feature.Var {
							case "muc_passwordprotected":
								password_protected = true
								addFeature("muc_passwordprotected", loadedLocale["muc_passwordprotected_description"])
							case "muc_unsecured":
								addFeature("muc_unsecured", loadedLocale["muc_unsecured_description"])
							case "muc_membersonly":
								addFeature("muc_membersonly", loadedLocale["muc_membersonly_description"])
							case "muc_open":
								addFeature("muc_open", loadedLocale["muc_open_description"])
							case "muc_moderated":
								addFeature("muc_moderated", loadedLocale["muc_moderated_description"])
							case "muc_unmoderated":
								addFeature("muc_unmoderated", loadedLocale["muc_unmoderated_description"])
							case "muc_nonanonymous":
								addFeature("muc_nonanonymous", loadedLocale["muc_nonanonymous_description"])
							case "muc_semianonymous":
								addFeature("muc_semianonymous", loadedLocale["muc_semianonymous_description"])
							case "muc_persistent":
								addFeature("muc_persistent", loadedLocale["muc_persistent_description"])
							case "muc_temporary":
								addFeature("muc_temporary", loadedLocale["muc_temporary_description"])
							case "muc_public":
								addFeature("muc_public", loadedLocale["muc_public_description"])
							case "muc_hidden":
								addFeature("muc_hidden", loadedLocale["muc_hidden_description"])
							case "urn:xmpp:mam:0":
								addFeature("ok", loadedLocale["urn:xmpp:mam_description"])
							case "urn:xmpp:message-moderate:0":
								addFeature("moderate", loadedLocale["urn:xmpp:message-moderate_description"])
								/*
									default:
										addFeature("comment", feature.Var)
								*/
							}
						}

						warning_box.Append(buttons)
						warning_win.SetChild(warning_box)
						warning_win.Present()
					} else {
						allowed = false
						showErrorDialog(fmt.Errorf(loadedLocale["discoFail"]), win)
					}
				} else {
					allowed = false
					if result.Error != nil {
						showErrorDialog(fmt.Errorf("%s: %s - %s", loadedLocale["discoFail"], result.Error.Reason, result.Error.Text), win)
					} else {
						showErrorDialog(fmt.Errorf(loadedLocale["discoFail"]), win)
					}
				}

				if allowed {
					jm(res.Identity[0].Name, "")
				}
			}
			win.SetVisible(false)
		})

		win.SetTransientFor(win)
		win.Present()
	})

	app.AddAction(joinAction)
	app.AddAction(aboutAction)
	app.AddAction(destroymucAction)
	app.AddAction(configureMucAction)
	app.AddAction(startDmAction)
	app.AddAction(viewAffilsMucAction)

	the_menu.AppendSubmenu("MUC", fileMenu)
	the_menu.AppendSubmenu("DM", dmMenu)
	the_menu.AppendSubmenu("Help", helpMenu)

	the_menuBar := gtk.NewPopoverMenuBarFromModel(the_menu)
	app.SetMenubar(gio.NewMenu())

	window.SetTitle(loadedLocale["appName"])
	window.Window.AddCSSClass("ssd")
	window.Window.SetDefaultSize(500, 500)
	menu = gtk.NewBox(gtk.OrientationVertical, 0)

	empty_dialog = gtk.NewImageFromPaintable(clientAssetsLoad("disabled_logo"))
	empty_dialog.SetPixelSize(100)
	empty_dialog.SetVExpand(true)

	scroller = gtk.NewScrolledWindow()
	memberList = gtk.NewScrolledWindow()

	scroller.SetHExpand(true)
	memberList.SetHExpand(true)

	box := gtk.NewBox(gtk.OrientationVertical, 0)
	box.Append(the_menuBar)

	statBar := gtk.NewBox(gtk.OrientationHorizontal, 0)

	cBox := gtk.NewBox(gtk.OrientationHorizontal, 0)
	connectionIcon = gtk.NewImageFromPaintable((clientAssetsLoad("disconnect")))
	connectionIcon.AddCSSClass("icon")
	connectionStatus = gtk.NewLabel(loadedLocale["disconnected"])

	cBox.Append(connectionIcon)
	cBox.Append(connectionStatus)

	statBar.Append(cBox)

	mBox := gtk.NewBox(gtk.OrientationHorizontal, 0)

	gesture1 := gtk.NewGestureClick()
	gesture1.SetButton(1)
	gesture1.Connect("pressed", func() {
		current = mStatus.Text()
		switchToTab(current, &window.Window)
	})

	mIcon = gtk.NewImageFromPaintable((clientAssetsLoad("comment")))
	mIcon.AddCSSClass("icon")
	mStatus = gtk.NewLabel("-")
	mStatus.AddController(gesture1)

	gIcon = gtk.NewImageFromPaintable((clientAssetsLoad("timeline_marker")))
	gIcon.AddCSSClass("icon")
	gStatus = gtk.NewLabel("...")

	cBox.Append(mIcon)
	cBox.Append(mStatus)

	cBox.Append(gIcon)
	cBox.Append(gStatus)

	statBar.Append(mBox)

	pBox := gtk.NewBox(gtk.OrientationHorizontal, 0)
	pBox.SetTooltipText(loadedLocale["pingBarTooltip"])
	gesture := gtk.NewGestureClick()
	gesture.SetButton(3)
	gesture.Connect("pressed", func() {
		opt := charts.NewLineChartOptionWithData(pingTimes)
		opt.Title = charts.TitleOption{
			Text: loadedLocale["pingGraphTitle"],
		}

		opt.Legend = charts.LegendOption{
			SeriesNames: []string{
				loadedLocale["pingGraphYAxis"],
			},
		}

		opt.StrokeSmoothingTension = 0.9

		p := charts.NewPainter(charts.PainterOptions{
			Width:  600,
			Height: 400,
		})
		err := p.LineChart(opt)
		if err != nil {
			panic(err)
		}

		buf, err := p.Bytes()
		if err != nil {
			panic(err)
		}

		loader := gdkpixbuf.NewPixbufLoader()
		loader.Write(buf)
		loader.Close()

		i := gtk.NewPictureForPaintable(gdk.NewTextureForPixbuf(loader.Pixbuf()))
		win := gtk.NewWindow()
		win.SetDefaultSize(600, 400)
		win.SetResizable(false)
		win.SetTitle(loadedLocale["pingGraphTitle"])
		box := gtk.NewBox(gtk.OrientationVertical, 0)
		box.Append(i)
		win.SetChild(box)
		win.SetVisible(true)
	})
	pBox.AddController(gesture)

	i := (gtk.NewImageFromPaintable(clientAssetsLoad("chart_bar")))
	i.AddCSSClass("icon")

	pBox.Append(i)
	pingStatus = gtk.NewLabel("...")
	pBox.Append(pingStatus)
	statBar.Append(pBox)

	scrollerStatBar := gtk.NewScrolledWindow()
	scrollerStatBar.SetChild(statBar)
	box.Append(scrollerStatBar)

	scroller.SetChild(empty_dialog)
	menu_scroll := gtk.NewScrolledWindow()
	menu_scroll.SetHExpand(true)

	menu_scroll.SetChild(menu)

	chatbox := gtk.NewBox(gtk.OrientationHorizontal, 0)
	chat_pane := gtk.NewPaned(gtk.OrientationHorizontal)
	chat_pane.SetStartChild(scroller)
	chat_pane.SetEndChild(memberList)
	chat_pane.SetPosition(225)

	main_pane := gtk.NewPaned(gtk.OrientationHorizontal)
	main_pane.SetStartChild(menu_scroll)
	main_pane.SetEndChild(chat_pane)
	main_pane.SetPosition(135)

	chatbox.Append(main_pane)
	box.Append(chatbox)

	entry_box := gtk.NewBox(gtk.OrientationHorizontal, 0)

	oob_en := gtk.NewEntry()
	oob_en.SetPlaceholderText("URL")

	message_en = gtk.NewEntry()
	message_en.SetPlaceholderText(loadedLocale["messageEntryPlaceholder"])
	b := gtk.NewButtonWithLabel(loadedLocale["send"])

	sendtxt := func() {
		t := message_en.Text()

		message_type := stanza.MessageTypeChat
		tab, ok := tabs.Load(current)
		if !ok {
			return
		}

		typed_tab := tab.(*chatTab)
		if typed_tab.isMuc {
			message_type = stanza.MessageTypeGroupchat

			// First check if the user is a visitor
			mu, ok := mucmembers.Load(current)
			if ok {
				typed_mu := mu.(mucUnit)
				typed_mu.Members.Range(func(k, v any) bool {
					user, ok := v.(stanza.Presence)
					if ok {
						var mui MucUser
						ok = user.Get(&mui)
						if ok && mui.MucUserItem.JID != "" {
							if JidMustParse(mui.MucUserItem.JID).Bare() == JidMustParse(clientroot.Session.BindJid).Bare() {
								if mui.MucUserItem.Role == "visitor" {
									win := gtk.NewWindow()
									win.SetDefaultSize(1, 1)
									box := gtk.NewBox(gtk.OrientationVertical, 5)
									txt := gtk.NewLabel("You are a visitor and do not have voice.\nWould you like to request voice from the moderators of this MUC?")
									btn := gtk.NewButtonWithLabel("Request voice")
									btn.ConnectClicked(func() {
										sendVoiceRequest(client, current)
										win.SetVisible(false)
									})
									dismiss := gtk.NewButtonWithLabel("Dismiss")
									dismiss.ConnectClicked(func() {
										win.SetVisible(false)
									})

									box.Append(txt)
									box.Append(btn)
									box.Append(dismiss)

									win.SetChild(box)
									win.SetResizable(false)
									win.SetVisible(true)
								}

								return false
							}
						}
					}

					return true
				})
			}
		}

		exts := []stanza.MsgExtension{}
		if oob_en.Text() != "" {
			new_oob := new(stanza.OOB)
			new_oob.URL = oob_en.Text()
			exts = append(exts, new_oob)
		}

		if strings.Contains(t, "@everyone") {
			start := strings.Index(t, "@everyone")
			end := start + len("@everyone")

			new_mention := new(Mention)
			new_mention.Mentions = "urn:xmpp:mentions:0#channel"

			new_mention.Begin = start
			new_mention.End = end

			exts = append(exts, new_mention)
		} else if strings.Contains(t, "@here") {
			new_attention := new(Attention)
			exts = append(exts, new_attention)
		}

		err := sendMessage(client, current, message_type, t, "", "", exts)
		if err != nil {
			showErrorDialog(err, &window.Window)
		}
		message_en.SetText("")
		scrollToBottomAfterUpdate(scroller)
	}

	message_en.Connect("activate", sendtxt)

	b.ConnectClicked(sendtxt)

	message_en.SetHExpand(true)

	entry_box.Append(oob_en)
	entry_box.Append(message_en)
	entry_box.Append(b)

	box.Append(entry_box)

	typingStatus = gtk.NewLabel("")
	box.Append(typingStatus)

	window.SetChild(box)

	window.SetVisible(true)
}

func loadCSS(content string) *gtk.CSSProvider {
	prov := gtk.NewCSSProvider()
	prov.LoadFromString(content)
	return prov
}