morpheus.meta

63.diff (202222B)

---

 diff --git a/.circleci/config.yml b/.circleci/config.yml
 index 8655879..f460b8d 100644
 --- a/.circleci/config.yml
 +++ b/.circleci/config.yml
 @@ -38,6 +38,10 @@ jobs:
        - attach_workspace:
            # Must be absolute path or relative path from working_directory
            at: /home/user/work/
 +      - run:
 +          name: Update Build Deps
 +          working_directory: /home/user/work/src/github.com/Nordgedanken/Morpheus/
 +          command: apt-get update -y -qq && apt-get install apt -y -qq && add-apt-repository ppa:ubuntu-toolchain-r/test -y && apt-get update -y -qq && apt-get -y -qq install gcc-5 g++-5 && rm -f /usr/bin/gcc && ln -s /usr/bin/gcc-5 /usr/bin/gcc && rm -f /usr/bin/g++ && ln -s /usr/bin/g++-5 /usr/bin/g++
        - run:
            name: Run Build
            working_directory: /home/user/work/src/github.com/Nordgedanken/Morpheus/
 @@ -67,12 +71,12 @@ jobs:
        - run:
            name: Build Tests
            working_directory: /home/user/work/src/github.com/Nordgedanken/Morpheus/
 -          command: $GOPATH/bin/ginkgo build /home/user/work/src/github.com/Nordgedanken/Morpheus/
 +          command: $GOPATH/bin/ginkgo build --cover /home/user/work/src/github.com/Nordgedanken/Morpheus/
            no_output_timeout: 1200
        - run:
            name: Run Tests
            working_directory: /home/user/work/src/github.com/Nordgedanken/Morpheus/
 -          command: $GOPATH/bin/ginkgo -r -p --randomizeAllSpecs --randomizeSuites --failOnPending --trace --race --progress /home/user/work/src/github.com/Nordgedanken/Morpheus/Morpheus.test
 +          command: $GOPATH/bin/ginkgo --cover --coverprofile=c.out -r -p --randomizeAllSpecs --randomizeSuites --failOnPending --trace --race --progress /home/user/work/src/github.com/Nordgedanken/Morpheus/Morpheus.test
            no_output_timeout: 1200
        - run:
            name: Debug Print directory
 @@ -81,6 +85,22 @@ jobs:
            command: ls -lah
        - store_test_results:
                path: /home/user/work/src/github.com/Nordgedanken/Morpheus/junit.xml
 +  lint:
 +    docker:
 +      - image: therecipe/qt:linux
 +    steps:
 +      - attach_workspace:
 +          # Must be absolute path or relative path from working_directory
 +          at: /home/user/work/
 +      - run:
 +          name: Generate additional binding files
 +          working_directory: /home/user/work/src/github.com/Nordgedanken/Morpheus/
 +          command: $GOPATH/bin/qtrcc desktop && $GOPATH/bin/qtmoc desktop
 +      - run:
 +          name: Run Lint
 +          working_directory: /home/user/work/src/github.com/Nordgedanken/Morpheus/
 +          command: chmod +x scripts/lint.sh && scripts/lint.sh
 +          no_output_timeout: 1200
    build_win_static:
      docker:
        - image: therecipe/qt:windows_64_static
 @@ -109,6 +129,9 @@ workflows:
        - test:
            requires:
              - prepare
 +      - lint:
 +          requires:
 +            - prepare
  notify:
    webhooks:
      - url: https://riot.nordgedanken.de:4051/services/hooks/Y2lyY2xlY2lfc2VydmljZQ
 diff --git a/.gitignore b/.gitignore
 index fbc1321..e1da019 100644
 --- a/.gitignore
 +++ b/.gitignore
 @@ -18,6 +18,7 @@ debug*
  log/
  data/
  ui/moc*
 +matrix/moc*
  .idea/
  Morpheus.exe
  Morpheus.msi
 \ No newline at end of file
 diff --git a/README.md b/README.md
 index 0255893..7ffd929 100644
 --- a/README.md
 +++ b/README.md
 @@ -2,6 +2,8 @@
  [![CircleCI branch](https://img.shields.io/circleci/project/github/Nordgedanken/Morpheus/master.svg)](https://circleci.com/gh/Nordgedanken/Morpheus)
  
  [![Github All Releases](https://img.shields.io/github/downloads/Nordgedanken/Morpheus/total.svg)]()
 +
 +[![Go Report Card](https://goreportcard.com/badge/github.com/Nordgedanken/Morpheus)](https://goreportcard.com/report/github.com/Nordgedanken/Morpheus)
  ---
  
  A Matrix client written in Go-QT
 diff --git a/artwork/34c3Banner.jpg b/artwork/34c3Banner.jpg
 new file mode 100644
 index 0000000..c46c007
 Binary files /dev/null and b/artwork/34c3Banner.jpg differ
 diff --git a/artwork/34c3Banner.xcf b/artwork/34c3Banner.xcf
 new file mode 100644
 index 0000000..fc0849a
 Binary files /dev/null and b/artwork/34c3Banner.xcf differ
 diff --git a/artwork/Morpheus Long Logo with link.xcf b/artwork/Morpheus Long Logo with link.xcf
 new file mode 100644
 index 0000000..0b9b0f0
 Binary files /dev/null and b/artwork/Morpheus Long Logo with link.xcf differ
 diff --git a/artwork/Morpheus Long Logo.png b/artwork/Morpheus Long Logo.png
 new file mode 100644
 index 0000000..b70ac9a
 Binary files /dev/null and b/artwork/Morpheus Long Logo.png differ
 diff --git a/artwork/Morpheus Long Logo.xcf b/artwork/Morpheus Long Logo.xcf
 new file mode 100644
 index 0000000..4f5577b
 Binary files /dev/null and b/artwork/Morpheus Long Logo.xcf differ
 diff --git a/linter.json b/linter.json
 index 14230e7..2b2b1f4 100644
 --- a/linter.json
 +++ b/linter.json
 @@ -1,5 +1,5 @@
  {
 -  "Vendor": false,
 +  "Vendor": true,
    "Cyclo": 12,
    "Deadline": "5m",
    "Enable": [
 diff --git a/main.go b/main.go
 index b20f4a0..9f05cfe 100644
 --- a/main.go
 +++ b/main.go
 @@ -8,7 +8,6 @@ import (
  
  	"github.com/Nordgedanken/Morpheus/matrix"
  	"github.com/Nordgedanken/Morpheus/matrix/db"
 -	"github.com/Nordgedanken/Morpheus/matrix/scalar"
  	"github.com/Nordgedanken/Morpheus/ui"
  	"github.com/Nordgedanken/dugong"
  	"github.com/matrix-org/gomatrix"
 @@ -20,6 +19,8 @@ import (
  )
  
  var window *widgets.QMainWindow
 +var mainUIStruct *ui.MainUI
 +var loginUIStruct *ui.LoginUI
  
  func main() {
  	runtime.GOMAXPROCS(128)
 @@ -110,41 +111,28 @@ func main() {
  
  		//Show MainUI
  		for result := range results {
 -			//TODO Don't switch screen on wrong login data.
 -			MainUIStruct := ui.NewMainUIStruct(windowWidth, windowHeight, window)
 -			MainUIStruct.SetCli(result)
 -			mainUIErr := MainUIStruct.NewUI()
 +			mainUIStruct = ui.NewMainUIStruct(windowWidth, windowHeight, window)
 +			mainUIStruct.SetCli(result)
 +			mainUIErr := mainUIStruct.NewUI()
  			if mainUIErr != nil {
  				log.Errorln("mainUI: ", mainUIErr)
  				return
  			}
  
 -			//scalarTokenTest
 -			openIdToken, OpenIDerr := scalar.GetOpenIDToken(MainUIStruct.GetCli())
 -			if OpenIDerr != nil {
 -				log.Warnln(OpenIDerr)
 -			}
 -			scalarToken, ScalarRegisterErr := scalar.GetScalarToken(MainUIStruct.GetCli(), openIdToken)
 -			if ScalarRegisterErr != nil {
 -				log.Warnln(ScalarRegisterErr)
 -			}
 -
 -			log.Infoln(scalarToken)
 -
 -			MainUIStruct.GetWidget().Resize2(windowWidth, windowHeight)
 -			window.SetCentralWidget(MainUIStruct.GetWidget())
 +			mainUIStruct.GetWidget().Resize2(windowWidth, windowHeight)
 +			window.SetCentralWidget(mainUIStruct.GetWidget())
  		}
  	} else {
  		//Show loginUI
 -		LoginUIStruct := ui.NewLoginUIStruct(windowWidth, windowHeight, window)
 -		loginUIErr := LoginUIStruct.NewUI()
 +		loginUIStruct = ui.NewLoginUIStruct(windowWidth, windowHeight, window)
 +		loginUIErr := loginUIStruct.NewUI()
  		if loginUIErr != nil {
  			log.Errorln("Login Err: ", loginUIErr)
  			return
  		}
  
 -		LoginUIStruct.GetWidget().Resize2(windowWidth, windowHeight)
 -		window.SetCentralWidget(LoginUIStruct.GetWidget())
 +		loginUIStruct.GetWidget().Resize2(windowWidth, windowHeight)
 +		window.SetCentralWidget(loginUIStruct.GetWidget())
  	}
  
  	window.Resize2(windowWidth, windowHeight)
 @@ -164,6 +152,21 @@ func main() {
  
  func cleanup() bool {
  	log.Infoln("cleanup")
 +
 +	if mainUIStruct != nil {
 +		if mainUIStruct.GetCli() != nil {
 +			log.Infoln("Stop Sync")
 +			mainUIStruct.GetCli().StopSync()
 +		}
 +	}
 +
 +	if loginUIStruct != nil {
 +		if loginUIStruct.GetCli() != nil {
 +			log.Infoln("Stop Sync")
 +			loginUIStruct.GetCli().StopSync()
 +		}
 +	}
 +
  	UserDB, DBOpenErr := db.OpenUserDB()
  	if DBOpenErr != nil {
  		log.Errorln(DBOpenErr)
 diff --git a/matrix/db/db.go b/matrix/db/db.go
 index cc1b971..942aa01 100644
 --- a/matrix/db/db.go
 +++ b/matrix/db/db.go
 @@ -5,31 +5,36 @@ import (
  	"os"
  	"path/filepath"
  	"strconv"
 -	"sync"
  
  	"github.com/dgraph-io/badger"
  	"github.com/shibukawa/configdir"
  )
  
 -var UserDB *badger.DB
 -var CacheDB *badger.DB
 -var onceCache sync.Once
 -var onceUser sync.Once
 +var userDB *badger.DB
 +var cacheDB *badger.DB
 +var onceCache Once
 +var onceUser Once
 +
 +func ResetOnceUser() {
 +	onceUser.Reset()
 +}
  
  // OpenCacheDB opens or generates the Database file for settings and Cache
  func OpenCacheDB() (db *badger.DB, err error) {
  	onceCache.Do(func() {
  		// Open the data.db file. It will be created if it doesn't exist.
  		configDirs := configdir.New("Nordgedanken", "Morpheus")
 -		if _, StatErr := os.Stat(filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path) + "/data/"); os.IsNotExist(StatErr) {
 -			MkdirErr := os.MkdirAll(filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path)+"/data/", 0755)
 +		filePath := filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path)
 +
 +		if _, StatErr := os.Stat(filePath + "/data/"); os.IsNotExist(StatErr) {
 +			MkdirErr := os.MkdirAll(filePath+"/data/", 0700)
  			if MkdirErr != nil {
  				err = MkdirErr
  				return
  			}
  		}
 -		if _, StatErr := os.Stat(filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path) + "/data/cache/"); os.IsNotExist(StatErr) {
 -			MkdirErr := os.MkdirAll(filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path)+"/data/cache/", 0755)
 +		if _, StatErr := os.Stat(filePath + "/data/cache/"); os.IsNotExist(StatErr) {
 +			MkdirErr := os.MkdirAll(filePath+"/data/cache/", 0700)
  			if MkdirErr != nil {
  				err = MkdirErr
  				return
 @@ -37,23 +42,31 @@ func OpenCacheDB() (db *badger.DB, err error) {
  		}
  		opts := badger.DefaultOptions
  		opts.SyncWrites = false
 -		opts.Dir = filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path) + "/data/cache"
 -		opts.ValueDir = filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path) + "/data/cache"
 +		opts.Dir = filePath + "/data/cache"
 +		opts.ValueDir = filePath + "/data/cache"
 +
 +		if _, StatErr := os.Stat(filePath + "/data/cache/LOCK"); StatErr == nil {
 +			DeleteErr := os.Remove(filePath + "/data/cache/LOCK")
 +			if DeleteErr != nil {
 +				err = DeleteErr
 +				return
 +			}
 +		}
  
  		expDB, DBErr := badger.Open(opts)
  		if DBErr != nil {
  			err = DBErr
  			return
  		}
 -		CacheDB = expDB
 +		userDB = expDB
  	})
  
 -	if CacheDB == nil {
 +	if userDB == nil {
  		err = errors.New("missing CacheDB")
  		return
  	}
  
 -	db = CacheDB
 +	db = userDB
  	return
  }
  
 @@ -62,15 +75,17 @@ func OpenUserDB() (db *badger.DB, err error) {
  	onceUser.Do(func() {
  		// Open the data.db file. It will be created if it doesn't exist.
  		configDirs := configdir.New("Nordgedanken", "Morpheus")
 -		if _, StatErr := os.Stat(filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path) + "/data/"); os.IsNotExist(StatErr) {
 -			MkdirErr := os.MkdirAll(filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path)+"/data/", 0755)
 +		filePath := filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path)
 +
 +		if _, StatErr := os.Stat(filePath + "/data/"); os.IsNotExist(StatErr) {
 +			MkdirErr := os.MkdirAll(filePath+"/data/", 0700)
  			if MkdirErr != nil {
  				err = MkdirErr
  				return
  			}
  		}
 -		if _, StatErr := os.Stat(filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path) + "/data/user/"); os.IsNotExist(StatErr) {
 -			MkdirErr := os.MkdirAll(filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path)+"/data/user/", 0755)
 +		if _, StatErr := os.Stat(filePath + "/data/user/"); os.IsNotExist(StatErr) {
 +			MkdirErr := os.MkdirAll(filePath+"/data/user/", 0700)
  			if MkdirErr != nil {
  				err = MkdirErr
  				return
 @@ -78,8 +93,16 @@ func OpenUserDB() (db *badger.DB, err error) {
  		}
  		opts := badger.DefaultOptions
  		opts.SyncWrites = false
 -		opts.Dir = filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path) + "/data/user"
 -		opts.ValueDir = filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path) + "/data/user"
 +		opts.Dir = filePath + "/data/user"
 +		opts.ValueDir = filePath + "/data/user"
 +
 +		if _, StatErr := os.Stat(filePath + "/data/user/LOCK"); StatErr == nil {
 +			DeleteErr := os.Remove(filePath + "/data/user/LOCK")
 +			if DeleteErr != nil {
 +				err = DeleteErr
 +				return
 +			}
 +		}
  
  		expDB, DBErr := badger.Open(opts)
  		if DBErr != nil {
 @@ -87,15 +110,15 @@ func OpenUserDB() (db *badger.DB, err error) {
  			return
  		}
  
 -		UserDB = expDB
 +		cacheDB = expDB
  	})
  
 -	if UserDB == nil {
 +	if cacheDB == nil {
  		err = errors.New("missing UserDB")
  		return
  	}
  
 -	db = UserDB
 +	db = cacheDB
  	return
  }
  
 @@ -136,3 +159,21 @@ func CacheMessageEvents(id, sender, roomID, message string, timestamp int64) (er
  
  	return
  }
 +
 +// Get dedpulicates all the Gets inside the Database to not repeat that much code.
 +func Get(txn *badger.Txn, key []byte) (result []byte, err error) {
 +	item, QueryErr := txn.Get(key)
 +	if QueryErr != nil && QueryErr != badger.ErrKeyNotFound {
 +		err = QueryErr
 +		return
 +	}
 +	if QueryErr != badger.ErrKeyNotFound {
 +		valueByte, valueErr := item.Value()
 +		result = valueByte
 +		if valueErr != nil {
 +			err = valueErr
 +			return
 +		}
 +	}
 +	return
 +}
 diff --git a/matrix/db/once.go b/matrix/db/once.go
 new file mode 100644
 index 0000000..8f0f987
 --- /dev/null
 +++ b/matrix/db/once.go
 @@ -0,0 +1,38 @@
 +package db
 +
 +import (
 +	"sync"
 +	"sync/atomic"
 +)
 +
 +// Once is an object that will perform exactly one action
 +// until Reset is called.
 +// See http://golang.org/pkg/sync/#Once
 +type Once struct {
 +	m    sync.Mutex
 +	done uint32
 +}
 +
 +// Do simulates sync.Once.Do by executing the specified function
 +// only once, until Reset is called.
 +// See http://golang.org/pkg/sync/#Once
 +func (o *Once) Do(f func()) {
 +	if atomic.LoadUint32(&o.done) == 1 {
 +		return
 +	}
 +	// Slow-path.
 +	o.m.Lock()
 +	defer o.m.Unlock()
 +	if o.done == 0 {
 +		defer atomic.StoreUint32(&o.done, 1)
 +		f()
 +	}
 +}
 +
 +// Reset indicates that the next call to Do should actually be called
 +// once again.
 +func (o *Once) Reset() {
 +	o.m.Lock()
 +	defer o.m.Unlock()
 +	atomic.StoreUint32(&o.done, 0)
 +}
 diff --git a/matrix/db/storer.go b/matrix/db/storer.go
 index a898e40..b79f627 100644
 --- a/matrix/db/storer.go
 +++ b/matrix/db/storer.go
 @@ -1,6 +1,8 @@
  package db
  
  import (
 +	"fmt"
 +
  	"github.com/dgraph-io/badger"
  )
  
 @@ -10,6 +12,7 @@ type Storer interface {
  	LoadNextBatch(userID string) (nextBatch string, err error)
  }
  
 +// MorpheusStorage is the StorageInterface which needs to be conformed to in order to persist Go-NEB data
  type MorpheusStorage struct {
  	Database *badger.DB
  }
 @@ -31,18 +34,11 @@ func (m *MorpheusStorage) UpdateNextBatch(userID, nextBatch string) (err error)
  // LoadNextBatch loads the next_batch token for the given user.
  func (m *MorpheusStorage) LoadNextBatch(userID string) (nextBatch string, err error) {
  	DBerr := m.Database.View(func(txn *badger.Txn) error {
 -
 -		nextBatchItem, NextBatchErr := txn.Get([]byte("matrix|" + userID + "|nextBatch|"))
 -		if NextBatchErr != nil {
 -			return NextBatchErr
 +		nextBatchResult, QueryErr := Get(txn, []byte("user|accessToken"))
 +		if QueryErr != nil {
 +			return QueryErr
  		}
 -
 -		nextBatchByte, nextBatchByteErr := nextBatchItem.Value()
 -		if nextBatchByteErr != nil {
 -			return nextBatchByteErr
 -		}
 -
 -		nextBatch = string(nextBatchByte)
 +		nextBatch = fmt.Sprintf("%s", nextBatchResult)
  		return nil
  	})
  	if DBerr != nil {
 diff --git a/matrix/globalTypes/types.go b/matrix/globalTypes/types.go
 new file mode 100644
 index 0000000..8f24617
 --- /dev/null
 +++ b/matrix/globalTypes/types.go
 @@ -0,0 +1,44 @@
 +package globalTypes
 +
 +import (
 +	"github.com/Nordgedanken/Morpheus/matrix/db"
 +	"github.com/Nordgedanken/Morpheus/matrix/rooms"
 +	"github.com/Nordgedanken/Morpheus/ui/listLayouts"
 +	"github.com/matrix-org/gomatrix"
 +)
 +
 +// Config holds important reused information in the UI
 +type Config struct {
 +	Username string
 +	Password string
 +
 +	WindowWidth  int
 +	WindowHeight int
 +
 +	Rooms       map[string]*rooms.Room
 +	CurrentRoom string
 +
 +	MessageListLayout *listLayouts.QVBoxLayoutWithTriggerSlot
 +	RoomListLayout    *listLayouts.QRoomVBoxLayoutWithTriggerSlot
 +
 +	matrixClient
 +}
 +
 +type matrixClient struct {
 +	databases
 +	Cli *gomatrix.Client
 +}
 +
 +// GetCli returns the Matrix Client
 +func (mc *matrixClient) GetCli() *gomatrix.Client {
 +	return mc.Cli
 +}
 +
 +type databases struct {
 +	CacheDB db.Storer
 +}
 +
 +// SetCurrentRoom sets the new room ID of the MainUI
 +func (d *databases) SetCacheDB(db db.Storer) {
 +	d.CacheDB = db
 +}
 diff --git a/matrix/rooms.go b/matrix/rooms.go
 deleted file mode 100644
 index a594a81..0000000
 --- a/matrix/rooms.go
 +++ /dev/null
 @@ -1,210 +0,0 @@
 -package matrix
 -
 -import (
 -	"bytes"
 -	"image"
 -	"image/draw"
 -	"image/png"
 -	"strings"
 -
 -	"github.com/Nordgedanken/Morpheus/matrix/db"
 -	"github.com/dgraph-io/badger"
 -	"github.com/matrix-org/gomatrix"
 -	"github.com/rhinoman/go-commonmark"
 -	log "github.com/sirupsen/logrus"
 -	"github.com/therecipe/qt/gui"
 -)
 -
 -// Room saves the information of a Room
 -type Room struct {
 -	cli           *gomatrix.Client
 -	RoomID        string
 -	RoomName      string
 -	RoomAvatarURL string
 -	RoomTopic     string
 -}
 -
 -// NewRoom Inits a new Room struct
 -func NewRoom(roomID string, cli *gomatrix.Client) (room *Room) {
 -	room = &Room{RoomID: roomID, cli: cli}
 -	return
 -}
 -
 -func (r *Room) crawlRoomAvatarURL() {
 -	roomAvatar := struct {
 -		URL string `json:"url"`
 -	}{}
 -	r.cli.StateEvent(r.RoomID, "m.room.avatar", "", &roomAvatar)
 -	r.RoomAvatarURL = roomAvatar.URL
 -}
 -
 -func (r *Room) crawlRoomTopic() {
 -	roomTopic := struct {
 -		Topic string `json:"topic"`
 -	}{}
 -	r.cli.StateEvent(r.RoomID, "m.room.topic", "", &roomTopic)
 -	r.RoomTopic = roomTopic.Topic
 -}
 -
 -// GetRoomTopic returns the Topic of the Room and crawls it if needed
 -func (r *Room) GetRoomTopic() (topic string) {
 -	if r.RoomTopic == "" {
 -		r.crawlRoomTopic()
 -	}
 -
 -	mardownMessage := commonmark.Md2Html(r.RoomTopic, 0)
 -
 -	if mardownMessage == r.RoomTopic {
 -		topic = r.RoomTopic
 -		return
 -	} else {
 -		r.RoomTopic = mardownMessage
 -		topic = r.RoomTopic
 -		return
 -	}
 -}
 -
 -// GetRoomAvatar generates the Avatar Image for a Room
 -func (r *Room) GetRoomAvatar() (avatarResp *gui.QPixmap, err error) {
 -	// Get the Avatar URL if needed
 -	if r.RoomAvatarURL == "" {
 -		r.crawlRoomAvatarURL()
 -	}
 -
 -	// Get the image Data
 -	cacheDB, DBOpenErr := db.OpenCacheDB()
 -	if DBOpenErr != nil {
 -		log.Fatalln(DBOpenErr)
 -	}
 -
 -	// Init local vars
 -	var roomAvatarData []byte
 -	var IMGdata []byte
 -
 -	// Get cache
 -	DBErr := cacheDB.View(func(txn *badger.Txn) error {
 -		roomAvatarDataItem, QueryErr := txn.Get([]byte("room|" + r.RoomID + "|84x84"))
 -		if QueryErr != nil && QueryErr != badger.ErrKeyNotFound {
 -			return QueryErr
 -		}
 -		if QueryErr != badger.ErrKeyNotFound {
 -			roomAvatarDataBytes, roomAvatarDataErr := roomAvatarDataItem.Value()
 -			roomAvatarData = roomAvatarDataBytes
 -			return roomAvatarDataErr
 -		}
 -		return nil
 -	})
 -	if DBErr != nil {
 -		err = DBErr
 -		return
 -	}
 -
 -	//If cache is empty do a ServerQuery
 -	if len(roomAvatarData) <= 0 {
 -		// If avatarURL is not empty (aka. has a avatar set) download it at the size of 100x100. Else make the data string empty
 -		if r.RoomAvatarURL != "" {
 -			hsURL := r.cli.HomeserverURL.String()
 -			roomAvatarURLSplits := strings.Split(strings.Replace(r.RoomAvatarURL, "mxc://", "", -1), "/")
 -
 -			urlPath := hsURL + "/_matrix/media/r0/thumbnail/" + roomAvatarURLSplits[0] + "/" + roomAvatarURLSplits[1] + "?width=84&height=84&method=crop"
 -
 -			data, ReqErr := r.cli.MakeRequest("GET", urlPath, nil, nil)
 -			if ReqErr != nil {
 -				err = ReqErr
 -				return
 -			}
 -			IMGdata = data
 -		} else {
 -			log.Println("Generating Room Avatar")
 -			var GenerateImgErr error
 -			var roomName string
 -			if r.RoomName == "" {
 -				r.crawlRoomName()
 -			}
 -			roomName = r.RoomName
 -			log.Println(roomName)
 -			if roomName == "" {
 -				roomName = "#"
 -			}
 -			IMGdata, GenerateImgErr = generateGenericImages(roomName, 84)
 -			if GenerateImgErr != nil {
 -				err = GenerateImgErr
 -				return
 -			}
 -		}
 -
 -		// Update cache
 -		DBSetErr := cacheDB.Update(func(txn *badger.Txn) error {
 -			DBSetErr := txn.Set([]byte("room|"+r.RoomID+"|84x84"), IMGdata)
 -			return DBSetErr
 -		})
 -		if DBSetErr != nil {
 -			err = DBSetErr
 -			return
 -		}
 -
 -	} else {
 -		IMGdata = roomAvatarData
 -	}
 -
 -	reader := bytes.NewReader(IMGdata)
 -	srcIMG, _, DecodeErr := image.Decode(reader)
 -	if DecodeErr != nil {
 -		err = DecodeErr
 -	}
 -
 -	// Convert avatarimage to QPixmap for usage in QT
 -	canvas := image.NewRGBA(srcIMG.Bounds())
 -	cx := srcIMG.Bounds().Min.X + srcIMG.Bounds().Dx()/2
 -	cy := srcIMG.Bounds().Min.Y + srcIMG.Bounds().Dy()/2
 -	draw.DrawMask(canvas, canvas.Bounds(), srcIMG, image.ZP, &circle{image.Point{cx, cy}, cx}, image.ZP, draw.Over)
 -
 -	avatar := gui.NewQPixmap()
 -	buf := new(bytes.Buffer)
 -	ConvErr := png.Encode(buf, canvas)
 -	if ConvErr != nil {
 -		err = ConvErr
 -	}
 -
 -	str := buf.String()
 -	avatar.LoadFromData(str, uint(len(str)), "", 0)
 -	avatarResp = avatar
 -	return
 -}
 -
 -func (r *Room) crawlRoomName() {
 -	roomName := struct {
 -		Name string `json:"name"`
 -	}{}
 -	roomCanoncialAlias := struct {
 -		Alias string `json:"alias"`
 -	}{}
 -
 -	if roomNameStateEventErr := r.cli.StateEvent(r.RoomID, "m.room.name", "", &roomName); roomNameStateEventErr != nil {
 -		log.Println(roomNameStateEventErr)
 -		// Not returning as a Error NotFound is allowed
 -	}
 -	if roomName.Name == "" {
 -		if roomCanoncialAliasStateEventErr := r.cli.StateEvent(r.RoomID, "m.room.canonical_alias", "", &roomCanoncialAlias); roomCanoncialAliasStateEventErr != nil {
 -			log.Println(roomCanoncialAliasStateEventErr)
 -			// Not returning as a Error NotFound is allowed
 -		}
 -		if roomCanoncialAlias.Alias == "" {
 -			r.RoomName = r.RoomID
 -		} else {
 -			r.RoomName = roomCanoncialAlias.Alias
 -		}
 -	} else {
 -		r.RoomName = roomName.Name
 -	}
 -
 -}
 -
 -// GetRoomName gives you the name of the current Room
 -func (r *Room) GetRoomName() (name string) {
 -	if r.RoomName == "" {
 -		r.crawlRoomName()
 -	}
 -	name = r.RoomName
 -	return
 -}
 diff --git a/matrix/rooms/rooms.go b/matrix/rooms/rooms.go
 new file mode 100644
 index 0000000..9d13be7
 --- /dev/null
 +++ b/matrix/rooms/rooms.go
 @@ -0,0 +1,314 @@
 +package rooms
 +
 +import (
 +	"fmt"
 +	"strings"
 +
 +	"github.com/Nordgedanken/Morpheus/matrix"
 +	"github.com/Nordgedanken/Morpheus/matrix/db"
 +	"github.com/dgraph-io/badger"
 +	"github.com/matrix-org/gomatrix"
 +	"github.com/rhinoman/go-commonmark"
 +	log "github.com/sirupsen/logrus"
 +	"github.com/therecipe/qt/gui"
 +)
 +
 +const mRoomNameEv = "m.room.name"
 +const mRoomCanonicalAliasEv = "m.room.canonical_alias"
 +
 +// Room saves the information of a Room
 +type Room struct {
 +	cli               *gomatrix.Client
 +	RoomID            string
 +	RoomName          string
 +	RoomNameEventType string
 +	RoomAvatarURL     string
 +	RoomTopic         string
 +}
 +
 +// GetRooms either returns the joinedRoomsList from the Server or the cachedList
 +func GetRooms(cli *gomatrix.Client) (rooms []string, err error) {
 +	// Get Cache
 +	cacheDB, DBOpenErr := db.OpenCacheDB()
 +	if DBOpenErr != nil {
 +		log.Fatalln(DBOpenErr)
 +	}
 +
 +	var roomsString string
 +	DBErr := cacheDB.View(func(txn *badger.Txn) error {
 +		roomsResult, QueryErr := db.Get(txn, []byte("rooms"))
 +		if QueryErr != nil {
 +			return QueryErr
 +		}
 +		roomsString = fmt.Sprintf("%s", roomsResult)
 +		return nil
 +	})
 +	if DBErr != nil {
 +		err = DBErr
 +		return
 +	}
 +
 +	if roomsString == "" {
 +		roomsResp, ReqErr := cli.JoinedRooms()
 +		if ReqErr != nil {
 +			err = ReqErr
 +			return
 +		}
 +		rooms = roomsResp.JoinedRooms
 +		DBSetErr := cacheDB.Update(func(txn *badger.Txn) error {
 +			DBSetErr := txn.Set([]byte("rooms"), []byte(strings.Join(rooms, ",")))
 +			return DBSetErr
 +		})
 +		if DBSetErr != nil {
 +			err = DBSetErr
 +			return
 +		}
 +	} else {
 +		rooms = strings.Split(roomsString, ",")
 +	}
 +	return
 +}
 +
 +// NewRoom Inits a new Room struct
 +func NewRoom(roomID string, cli *gomatrix.Client) (room *Room) {
 +	room = &Room{RoomID: roomID, cli: cli}
 +	return
 +}
 +
 +func (r *Room) crawlRoomAvatarURL() {
 +	roomAvatar := struct {
 +		URL string `json:"url"`
 +	}{}
 +	r.cli.StateEvent(r.RoomID, "m.room.avatar", "", &roomAvatar)
 +	r.RoomAvatarURL = roomAvatar.URL
 +}
 +
 +func (r *Room) crawlRoomTopic() {
 +	roomTopic := struct {
 +		Topic string `json:"topic"`
 +	}{}
 +	r.cli.StateEvent(r.RoomID, "m.room.topic", "", &roomTopic)
 +	r.RoomTopic = roomTopic.Topic
 +}
 +
 +// GetRoomTopic returns the Topic of the Room and crawls it if needed
 +func (r *Room) GetRoomTopic() (topic string) {
 +	if r.RoomTopic == "" {
 +		r.crawlRoomTopic()
 +	}
 +
 +	mardownMessage := commonmark.Md2Html(r.RoomTopic, 0)
 +
 +	topic = r.RoomTopic
 +	if mardownMessage == r.RoomTopic {
 +		topic = r.RoomTopic
 +	} else {
 +		r.RoomTopic = mardownMessage
 +	}
 +	return
 +}
 +
 +// GetRoomAvatar generates the Avatar Image for a Room
 +func (r *Room) GetRoomAvatar() (avatarResp *gui.QPixmap, err error) {
 +	// Get the Avatar URL if needed
 +	if r.RoomAvatarURL == "" {
 +		r.crawlRoomAvatarURL()
 +	}
 +
 +	// Get the image Data
 +	cacheDB, DBOpenErr := db.OpenCacheDB()
 +	if DBOpenErr != nil {
 +		log.Fatalln(DBOpenErr)
 +	}
 +
 +	// Init local vars
 +	var roomAvatarData []byte
 +	var IMGdata []byte
 +
 +	// Get cache
 +	DBErr := cacheDB.View(func(txn *badger.Txn) error {
 +		roomAvatarDataResult, QueryErr := db.Get(txn, []byte("room|"+r.RoomID+"|84x84"))
 +		if QueryErr != nil {
 +			return QueryErr
 +		}
 +		roomAvatarData = roomAvatarDataResult
 +		return nil
 +	})
 +	if DBErr != nil {
 +		err = DBErr
 +		return
 +	}
 +
 +	//If cache is empty do a ServerQuery
 +	if len(roomAvatarData) <= 0 {
 +		// If avatarURL is not empty (aka. has a avatar set) download it at the size of 100x100. Else make the data string empty
 +		if r.RoomAvatarURL != "" {
 +			hsURL := r.cli.HomeserverURL.String()
 +			roomAvatarURLSplits := strings.Split(strings.Replace(r.RoomAvatarURL, "mxc://", "", -1), "/")
 +
 +			urlPath := hsURL + "/_matrix/media/r0/thumbnail/" + roomAvatarURLSplits[0] + "/" + roomAvatarURLSplits[1] + "?width=84&height=84&method=crop"
 +
 +			data, ReqErr := r.cli.MakeRequest("GET", urlPath, nil, nil)
 +			if ReqErr != nil {
 +				err = ReqErr
 +				return
 +			}
 +			IMGdata = data
 +		} else {
 +			log.Println("Generating Room Avatar")
 +			var GenerateImgErr error
 +			var roomName string
 +			if r.RoomName == "" {
 +				r.crawlRoomName()
 +			}
 +			roomName = r.RoomName
 +			log.Println(roomName)
 +			if roomName == "" {
 +				roomName = "#"
 +			}
 +			IMGdata, GenerateImgErr = matrix.GenerateGenericImages(roomName, 84)
 +			if GenerateImgErr != nil {
 +				err = GenerateImgErr
 +				return
 +			}
 +		}
 +
 +		// Update cache
 +		DBSetErr := cacheDB.Update(func(txn *badger.Txn) error {
 +			DBSetErr := txn.Set([]byte("room|"+r.RoomID+"|84x84"), IMGdata)
 +			return DBSetErr
 +		})
 +		if DBSetErr != nil {
 +			err = DBSetErr
 +			return
 +		}
 +
 +	} else {
 +		IMGdata = roomAvatarData
 +	}
 +
 +	avatar := gui.NewQPixmap()
 +
 +	str := string(IMGdata[:])
 +	avatar.LoadFromData(str, uint(len(str)), "", 0)
 +	avatarResp = avatar
 +	return
 +}
 +
 +func (r *Room) crawlRoomName() {
 +	roomName := struct {
 +		Name string `json:"name"`
 +	}{}
 +	roomCanonicalAlias := struct {
 +		Alias string `json:"alias"`
 +	}{}
 +
 +	if roomNameStateEventErr := r.cli.StateEvent(r.RoomID, mRoomNameEv, "", &roomName); roomNameStateEventErr != nil {
 +		log.Println(roomNameStateEventErr)
 +		// Not returning as a Error NotFound is allowed
 +	}
 +	if roomName.Name == "" {
 +		if roomCanonicalAliasStateEventErr := r.cli.StateEvent(r.RoomID, mRoomCanonicalAliasEv, "", &roomCanonicalAlias); roomCanonicalAliasStateEventErr != nil {
 +			log.Println(roomCanonicalAliasStateEventErr)
 +			// Not returning as a Error NotFound is allowed
 +		}
 +		if roomCanonicalAlias.Alias == "" {
 +			r.RoomNameEventType = "roomID"
 +			r.RoomName = r.RoomID
 +		} else {
 +			r.RoomNameEventType = mRoomCanonicalAliasEv
 +			r.RoomName = roomCanonicalAlias.Alias
 +		}
 +	} else {
 +		r.RoomNameEventType = mRoomNameEv
 +		r.RoomName = roomName.Name
 +	}
 +
 +}
 +
 +// UpdateRoomNameByEvent used to Update the Room Name of a Room when a Room Change Event comes down the Sync
 +func (r *Room) UpdateRoomNameByEvent(newName, evType string) {
 +	if r.RoomNameEventType == "" {
 +		r.getRoomNameEventTypeFromDB()
 +	}
 +	if r.RoomNameEventType == mRoomNameEv && r.RoomNameEventType == evType {
 +		r.RoomName = newName
 +		r.cacheRoomName()
 +	} else if r.RoomNameEventType != mRoomNameEv {
 +		r.RoomName = newName
 +		r.cacheRoomName()
 +	}
 +}
 +
 +func (r *Room) cacheRoomName() (err error) {
 +	cacheDB, DBOpenErr := db.OpenCacheDB()
 +	if DBOpenErr != nil {
 +		err = DBOpenErr
 +		return
 +	}
 +
 +	// Update cache
 +	DBSetErr := cacheDB.Update(func(txn *badger.Txn) error {
 +		DBSetErr := txn.Set([]byte("room|"+r.RoomID+"|nameEventType"), []byte(r.RoomNameEventType))
 +		if DBSetErr != nil {
 +			return DBSetErr
 +		}
 +
 +		DBSetErr = txn.Set([]byte("room|"+r.RoomID+"|name"), []byte(r.RoomName))
 +		return DBSetErr
 +	})
 +	if DBSetErr != nil {
 +		err = DBSetErr
 +		return
 +	}
 +	return
 +}
 +
 +func (r *Room) getRoomNameEventTypeFromDB() (err error) {
 +	cacheDB, DBOpenErr := db.OpenCacheDB()
 +	if DBOpenErr != nil {
 +		err = DBOpenErr
 +		return
 +	}
 +
 +	cacheDB.View(func(txn *badger.Txn) error {
 +		roomNameEventTypeResult, QueryErr := db.Get(txn, []byte("room|"+r.RoomID+"|nameEventType"))
 +		if QueryErr != nil {
 +			return QueryErr
 +		}
 +		r.RoomNameEventType = fmt.Sprintf("%s", roomNameEventTypeResult)
 +		return nil
 +	})
 +
 +	return
 +}
 +
 +func (r *Room) getRoomNameFromDB() (err error) {
 +	cacheDB, DBOpenErr := db.OpenCacheDB()
 +	if DBOpenErr != nil {
 +		err = DBOpenErr
 +		return
 +	}
 +
 +	cacheDB.View(func(txn *badger.Txn) error {
 +		roomNameResult, QueryErr := db.Get(txn, []byte("room|"+r.RoomID+"|name"))
 +		if QueryErr != nil {
 +			return QueryErr
 +		}
 +		r.RoomName = fmt.Sprintf("%s", roomNameResult)
 +		return nil
 +	})
 +
 +	return
 +}
 +
 +// GetRoomName gives you the name of the current Room
 +func (r *Room) GetRoomName() (name string) {
 +	r.getRoomNameFromDB()
 +	if r.RoomName == "" {
 +		r.crawlRoomName()
 +		r.cacheRoomName()
 +	}
 +	name = r.RoomName
 +	return
 +}
 diff --git a/matrix/scalar/client.go b/matrix/scalar/client.go
 deleted file mode 100644
 index bb7e57c..0000000
 --- a/matrix/scalar/client.go
 +++ /dev/null
 @@ -1,26 +0,0 @@
 -package scalar
 -
 -import "github.com/matrix-org/gomatrix"
 -
 -type OpenIDTokenResponse struct {
 -	AccessToken      string `json:"access_token"`
 -	TokenType        string `json:"token_type"`
 -	ExpiresIn        int    `json:"expires_in"`
 -	MatrixServerName string `json:"matrix_server_name"`
 -}
 -
 -func GetOpenIDToken(cli *gomatrix.Client) (resp *OpenIDTokenResponse, err error) {
 -	urlPath := cli.BuildURL("user", cli.UserID, "openid", "request_token")
 -	_, err = MakeRequest(cli, "POST", urlPath, "{}", &resp)
 -	return
 -}
 -
 -type ScalarRegisterResp struct {
 -	ScalarToken string `json:"scalar_token"`
 -}
 -
 -func GetScalarToken(cli *gomatrix.Client, openIDToken *OpenIDTokenResponse) (resp *ScalarRegisterResp, err error) {
 -	urlPath := "https://scalar.vector.im/api/register"
 -	_, err = cli.MakeRequest("POST", urlPath, openIDToken, &resp)
 -	return
 -}
 diff --git a/matrix/scalar/utils.go b/matrix/scalar/utils.go
 deleted file mode 100644
 index 821edcc..0000000
 --- a/matrix/scalar/utils.go
 +++ /dev/null
 @@ -1,65 +0,0 @@
 -package scalar
 -
 -import (
 -	"bytes"
 -	"encoding/json"
 -	"io/ioutil"
 -	"net/http"
 -
 -	"github.com/matrix-org/gomatrix"
 -)
 -
 -func MakeRequest(cli *gomatrix.Client, method string, httpURL string, reqBody string, resBody interface{}) ([]byte, error) {
 -	var req *http.Request
 -	var err error
 -	if reqBody != "" {
 -		byteString := []byte(reqBody)
 -		req, err = http.NewRequest(method, httpURL, bytes.NewBuffer(byteString))
 -	} else {
 -		req, err = http.NewRequest(method, httpURL, nil)
 -	}
 -
 -	if err != nil {
 -		return nil, err
 -	}
 -	req.Header.Set("Content-Type", "application/json")
 -	res, err := cli.Client.Do(req)
 -	if res != nil {
 -		defer res.Body.Close()
 -	}
 -	if err != nil {
 -		return nil, err
 -	}
 -	contents, err := ioutil.ReadAll(res.Body)
 -	if res.StatusCode/100 != 2 { // not 2xx
 -		var wrap error
 -		var respErr gomatrix.RespError
 -		if _ = json.Unmarshal(contents, &respErr); respErr.ErrCode != "" {
 -			wrap = respErr
 -		}
 -
 -		// If we failed to decode as RespError, don't just drop the HTTP body, include it in the
 -		// HTTP error instead (e.g proxy errors which return HTML).
 -		msg := "Failed to " + method + " JSON to " + req.URL.Path
 -		if wrap == nil {
 -			msg = msg + ": " + string(contents)
 -		}
 -
 -		return contents, gomatrix.HTTPError{
 -			Code:         res.StatusCode,
 -			Message:      msg,
 -			WrappedError: wrap,
 -		}
 -	}
 -	if err != nil {
 -		return nil, err
 -	}
 -
 -	if resBody != nil {
 -		if err = json.Unmarshal(contents, &resBody); err != nil {
 -			return nil, err
 -		}
 -	}
 -
 -	return contents, nil
 -}
 diff --git a/matrix/syncer/syncer.go b/matrix/syncer/syncer.go
 index 4b5d6ff..1be1738 100644
 --- a/matrix/syncer/syncer.go
 +++ b/matrix/syncer/syncer.go
 @@ -6,13 +6,17 @@ import (
  	"runtime/debug"
  	"time"
  
 +	"github.com/Nordgedanken/Morpheus/matrix/globalTypes"
 +	"github.com/Nordgedanken/Morpheus/matrix/rooms"
  	"github.com/matrix-org/gomatrix"
  )
  
 +//MorpheusSyncer holds the UserID, the used Storer and the listener
  type MorpheusSyncer struct {
  	UserID    string
  	Store     gomatrix.Storer
  	listeners map[string][]OnEventListener // event type to listeners array
 +	config    *globalTypes.Config
  }
  
  // OnEventListener can be used with DefaultSyncer.OnEventType to be informed of incoming events.
 @@ -41,7 +45,7 @@ func (s *MorpheusSyncer) ProcessResponse(res *gomatrix.RespSync, since string) (
  	}()
  
  	for roomID, roomData := range res.Rooms.Join {
 -		room := s.getOrCreateRoom(roomID)
 +		room := s.getOrCreateRoom(roomID, "join")
  		for _, event := range roomData.State.Events {
  			event.RoomID = roomID
  			room.UpdateState(&event)
 @@ -53,7 +57,7 @@ func (s *MorpheusSyncer) ProcessResponse(res *gomatrix.RespSync, since string) (
  		}
  	}
  	for roomID, roomData := range res.Rooms.Invite {
 -		room := s.getOrCreateRoom(roomID)
 +		room := s.getOrCreateRoom(roomID, "invite")
  		for _, event := range roomData.State.Events {
  			event.RoomID = roomID
  			room.UpdateState(&event)
 @@ -61,7 +65,7 @@ func (s *MorpheusSyncer) ProcessResponse(res *gomatrix.RespSync, since string) (
  		}
  	}
  	for roomID, roomData := range res.Rooms.Leave {
 -		room := s.getOrCreateRoom(roomID)
 +		room := s.getOrCreateRoom(roomID, "leave")
  		for _, event := range roomData.Timeline.Events {
  			if event.StateKey != nil {
  				event.RoomID = roomID
 @@ -121,7 +125,14 @@ func (s *MorpheusSyncer) shouldProcessResponse(resp *gomatrix.RespSync, since st
  }
  
  // getOrCreateRoom must only be called by the Sync() goroutine which calls ProcessResponse()
 -func (s *MorpheusSyncer) getOrCreateRoom(roomID string) *gomatrix.Room {
 +func (s *MorpheusSyncer) getOrCreateRoom(roomID, state string) *gomatrix.Room {
 +	// Add new Room to the List if new
 +	_, present := s.config.Rooms[roomID]
 +	if !present && state == "join" {
 +		s.config.Rooms[roomID] = rooms.NewRoom(roomID, s.config.GetCli())
 +		s.config.RoomListLayout.TriggerRoom(roomID)
 +	}
 +
  	room := s.Store.LoadRoom(roomID)
  	if room == nil { // create a new Room
  		room = gomatrix.NewRoom(roomID)
 diff --git a/matrix/user.go b/matrix/user.go
 index cb310ba..90b340c 100644
 --- a/matrix/user.go
 +++ b/matrix/user.go
 @@ -3,65 +3,22 @@ package matrix
  import (
  	"bytes"
  	"fmt"
 -	"image"
 -	"image/color"
 -	"image/draw"
 -	// image/gif needed to load gif images
 -	_ "image/gif"
 -	// image/jpeg needed to load jpeg images
 -	_ "image/jpeg"
  	"image/png"
 -	// image/png needed to load png images
 -	_ "image/png"
  	"strconv"
  	"strings"
  	"unicode"
  	"unicode/utf8"
  
 -	log "github.com/sirupsen/logrus"
 -
  	"github.com/Nordgedanken/Morpheus/matrix/db"
 +	"github.com/dgraph-io/badger"
  	"github.com/disintegration/letteravatar"
  	"github.com/matrix-org/gomatrix"
 +	log "github.com/sirupsen/logrus"
  	"github.com/therecipe/qt/gui"
 -
 -	"github.com/dgraph-io/badger"
 -	// golang.org/x/image/webp needed to load webp images
 -	_ "golang.org/x/image/webp"
 -
 -	// golang.org/x/image/bmp needed to load bmp images
 -	_ "golang.org/x/image/bmp"
 -
 -	// golang.org/x/image/riff needed to load riff images
 -	_ "golang.org/x/image/riff"
 -
 -	// golang.org/x/image/tiff needed to load tiff images
 -	_ "golang.org/x/image/tiff"
  )
  
 -type circle struct {
 -	p image.Point
 -	r int
 -}
 -
 -func (c *circle) ColorModel() color.Model {
 -	return color.AlphaModel
 -}
 -
 -func (c *circle) Bounds() image.Rectangle {
 -	return image.Rect(c.p.X-c.r, c.p.Y-c.r, c.p.X+c.r, c.p.Y+c.r)
 -}
 -
 -func (c *circle) At(x, y int) color.Color {
 -	xx, yy, rr := float64(x-c.p.X)+0.5, float64(y-c.p.Y)+0.5, float64(c.r)
 -	if xx*xx+yy*yy < rr*rr {
 -		return color.Alpha{A: 255}
 -	}
 -	return color.Alpha{A: 0}
 -}
 -
 -func generateGenericImages(displayname string, size int) (imgData []byte, err error) {
 -	identifier := displayname
 +// GenerateGenericImages generates a byte slice containing a Image with the starting char as symbol and a colored background
 +func GenerateGenericImages(identifier string, size int) (imgData []byte, err error) {
  	if (identifier[0] == '#' || identifier[0] == '!' || identifier[0] == '@') && len(identifier) > 1 {
  		identifier = identifier[1:]
  	}
 @@ -103,15 +60,11 @@ func GetUserAvatar(cli *gomatrix.Client, mxid string, size int) (avatarResp *gui
  
  	// Get cache
  	DBErr := cacheDB.View(func(txn *badger.Txn) error {
 -		roomAvatarDataItem, QueryErr := txn.Get([]byte("user|" + mxid + "|avatarData" + strconv.Itoa(size) + "x" + strconv.Itoa(size)))
 -		if QueryErr != nil && QueryErr != badger.ErrKeyNotFound {
 +		avatarDataResult, QueryErr := db.Get(txn, []byte("user|"+mxid+"|avatarData"+strconv.Itoa(size)+"x"+strconv.Itoa(size)))
 +		if QueryErr != nil {
  			return QueryErr
  		}
 -		if QueryErr != badger.ErrKeyNotFound {
 -			avatarDataBytes, avatarDataErr := roomAvatarDataItem.Value()
 -			avatarData = avatarDataBytes
 -			return avatarDataErr
 -		}
 +		avatarData = avatarDataResult
  		return nil
  	})
  	if DBErr != nil {
 @@ -151,7 +104,7 @@ func GetUserAvatar(cli *gomatrix.Client, mxid string, size int) (avatarResp *gui
  			DisplayNameResp, _ := cli.GetDisplayName(mxid)
  			DisplayName := DisplayNameResp.DisplayName
  			var GenerateImgErr error
 -			IMGdata, GenerateImgErr = generateGenericImages(DisplayName, size)
 +			IMGdata, GenerateImgErr = GenerateGenericImages(DisplayName, size)
  			if GenerateImgErr != nil {
  				err = GenerateImgErr
  				return
 @@ -171,70 +124,38 @@ func GetUserAvatar(cli *gomatrix.Client, mxid string, size int) (avatarResp *gui
  		IMGdata = avatarData
  	}
  
 -	r := bytes.NewReader(IMGdata)
 -	srcIMG, _, DecodeErr := image.Decode(r)
 -	if DecodeErr != nil {
 -		err = DecodeErr
 -	}
 -
 -	// Convert avatarimage to QPixmap for usage in QT
 -	canvas := image.NewRGBA(srcIMG.Bounds())
 -	cx := srcIMG.Bounds().Min.X + srcIMG.Bounds().Dx()/2
 -	cy := srcIMG.Bounds().Min.Y + srcIMG.Bounds().Dy()/2
 -	draw.DrawMask(canvas, canvas.Bounds(), srcIMG, image.ZP, &circle{image.Point{cx, cy}, cx}, image.ZP, draw.Over)
 -
  	avatar := gui.NewQPixmap()
 -	buf := new(bytes.Buffer)
 -	ConvErr := png.Encode(buf, canvas)
 -	if ConvErr != nil {
 -		err = ConvErr
 -	}
  
 -	str := buf.Bytes()
 +	str := string(IMGdata[:])
  
 -	avatar.LoadFromData(string(str[:]), uint(len(str)), "PNG", 0)
 +	avatar.LoadFromData(string(str[:]), uint(len(str)), "", 0)
  	avatarResp = avatar
  	return
  }
  
 +//GetUserDataFromCache gets the last User from the cache
  func GetUserDataFromCache() (accessToken, homeserverURL, userID string, err error) {
  	UserDB, err := db.OpenUserDB()
  
  	// Get cache
  	DBErr := UserDB.View(func(txn *badger.Txn) error {
 -		accessTokenItem, QueryErr := txn.Get([]byte("user|accessToken"))
 -		if QueryErr != nil && QueryErr != badger.ErrKeyNotFound {
 +		accessTokenResult, QueryErr := db.Get(txn, []byte("user|accessToken"))
 +		if QueryErr != nil {
  			return QueryErr
  		}
 -		if QueryErr != badger.ErrKeyNotFound {
 -			accessTokenByte, accessTokenErr := accessTokenItem.Value()
 -			accessToken = fmt.Sprintf("%s", accessTokenByte)
 -			if accessTokenErr != nil {
 -				return accessTokenErr
 -			}
 -		}
 +		accessToken = fmt.Sprintf("%s", accessTokenResult)
  
 -		homeserverURLItem, QueryErr := txn.Get([]byte("user|homeserverURL"))
 -		if QueryErr != nil && QueryErr != badger.ErrKeyNotFound {
 +		homeserverURLResult, QueryErr := db.Get(txn, []byte("user|homeserverURL"))
 +		if QueryErr != nil {
  			return QueryErr
  		}
 -		if QueryErr != badger.ErrKeyNotFound {
 -			homeserverURLByte, homeserverURLErr := homeserverURLItem.Value()
 -			homeserverURL = fmt.Sprintf("%s", homeserverURLByte)
 -			if homeserverURLErr != nil {
 -				return homeserverURLErr
 -			}
 -		}
 +		homeserverURL = fmt.Sprintf("%s", homeserverURLResult)
  
 -		userIDItem, QueryErr := txn.Get([]byte("user|userID"))
 -		if QueryErr != nil && QueryErr != badger.ErrKeyNotFound {
 +		userIDResult, QueryErr := db.Get(txn, []byte("user|userID"))
 +		if QueryErr != nil {
  			return QueryErr
  		}
 -		if QueryErr != badger.ErrKeyNotFound {
 -			userIDByte, userIDErr := userIDItem.Value()
 -			userID = fmt.Sprintf("%s", userIDByte)
 -			return userIDErr
 -		}
 +		userID = fmt.Sprintf("%s", userIDResult)
  		return nil
  	})
  	if DBErr != nil {
 diff --git a/qml/ui/chat.ui b/qml/ui/chat.ui
 index cbfeb47..460c534 100644
 --- a/qml/ui/chat.ui
 +++ b/qml/ui/chat.ui
 @@ -566,7 +566,7 @@ border-radius: 5px;</string>
        <item>
         <widget class="QScrollArea" name="roomScroll">
          <property name="sizePolicy">
 -         <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
 +         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
 @@ -676,9 +676,6 @@ border-radius: 2px;</string>
             <property name="text">
              <string/>
             </property>
 -           <property name="pixmap">
 -            <pixmap>../../../../../../../Downloads/MatrixHQ.png</pixmap>
 -           </property>
             <property name="scaledContents">
              <bool>true</bool>
             </property>
 @@ -712,7 +709,7 @@ border-radius: 2px;</string>
                </font>
               </property>
               <property name="text">
 -              <string>Matrix HQ</string>
 +              <string/>
               </property>
               <property name="wordWrap">
                <bool>true</bool>
 @@ -747,7 +744,7 @@ border-radius: 2px;</string>
                </font>
               </property>
               <property name="text">
 -              <string>The Official Matrix HQ - please come chat here! | To support Matrix.org development: https://patreon.com/matrixdotorg | Try http://riot.im/app for a glossy web client | Looking for homeserver hosting? Check out https://upcloud.com/matrix!</string>
 +              <string/>
               </property>
               <property name="textFormat">
                <enum>Qt::AutoText</enum>
 @@ -890,7 +887,7 @@ border-radius: 2px;</string>
               <x>0</x>
               <y>0</y>
               <width>601</width>
 -             <height>424</height>
 +             <height>469</height>
              </rect>
             </property>
             <property name="minimumSize">
 diff --git a/qml/ui/message.ui b/qml/ui/message.ui
 index e427e23..3a37ba9 100644
 --- a/qml/ui/message.ui
 +++ b/qml/ui/message.ui
 @@ -117,7 +117,7 @@ border: 0;
  border-radius:7px;</string>
          </property>
          <property name="text">
 -         <string>Test</string>
 +         <string/>
          </property>
          <property name="scaledContents">
           <bool>false</bool>
 @@ -153,7 +153,7 @@ border-radius:7px;</string>
              <string notr="true">color:grey;</string>
             </property>
             <property name="text">
 -            <string>MTRNord</string>
 +            <string/>
             </property>
             <property name="openExternalLinks">
              <bool>true</bool>
 @@ -174,7 +174,7 @@ border-radius:7px;</string>
              <string notr="true">color:grey;</string>
             </property>
             <property name="text">
 -            <string>Way to early to say a time^^</string>
 +            <string/>
             </property>
             <property name="alignment">
              <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
 diff --git a/qml/ui/ownmessage.ui b/qml/ui/ownmessage.ui
 index 9b18ed7..29dafb4 100644
 --- a/qml/ui/ownmessage.ui
 +++ b/qml/ui/ownmessage.ui
 @@ -114,7 +114,7 @@ border: 0;
  border-radius:7px;</string>
             </property>
             <property name="text">
 -            <string>Test</string>
 +            <string/>
             </property>
             <property name="scaledContents">
              <bool>false</bool>
 @@ -150,7 +150,7 @@ border-radius:7px;</string>
                 <string notr="true">color:grey;</string>
                </property>
                <property name="text">
 -               <string>Way to early to say a time^^</string>
 +               <string/>
                </property>
                <property name="alignment">
                 <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
 @@ -174,7 +174,7 @@ border-radius:7px;</string>
                 <string notr="true">color:grey;</string>
                </property>
                <property name="text">
 -               <string>MTRNord</string>
 +               <string/>
                </property>
                <property name="alignment">
                 <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
 diff --git a/qml/ui/room.ui b/qml/ui/room.ui
 index 50dfbc0..4969ef0 100644
 --- a/qml/ui/room.ui
 +++ b/qml/ui/room.ui
 @@ -129,7 +129,7 @@
           <string notr="true">border: 0;</string>
          </property>
          <property name="text">
 -         <string>Test</string>
 +         <string/>
          </property>
          <property name="scaledContents">
           <bool>false</bool>
 diff --git a/scripts/lint.sh b/scripts/lint.sh
 index b831caf..ca212a4 100644
 --- a/scripts/lint.sh
 +++ b/scripts/lint.sh
 @@ -25,8 +25,8 @@ then args="$args --enable-gc"
  fi
  
  echo "Installing lint search engine..."
 -go install github.com/alecthomas/gometalinter/
 -gometalinter --config=linter.json ./... --install
 +go get -u -v github.com/alecthomas/gometalinter/
 +$GOPATH/bin/gometalinter --config=linter.json ./... --install
  
  echo "Looking for lint..."
 -gometalinter ./... ${args}
 \ No newline at end of file
 +$GOPATH/bin/gometalinter ./... ${args} --skip=vendor --exclude "vendor" --exclude "moc" --exclude "qt"
 diff --git a/ui/LoginUI.go b/ui/LoginUI.go
 index dad233f..7a77a04 100644
 --- a/ui/LoginUI.go
 +++ b/ui/LoginUI.go
 @@ -4,6 +4,7 @@ import (
  	"sync"
  
  	"github.com/Nordgedanken/Morpheus/matrix"
 +	"github.com/Nordgedanken/Morpheus/matrix/globalTypes"
  	"github.com/matrix-org/gomatrix"
  	log "github.com/sirupsen/logrus"
  	"github.com/therecipe/qt/core"
 @@ -13,22 +14,22 @@ import (
  )
  
  // NewLoginUIStruct gives you a LoginUI struct with prefilled data
 -func NewLoginUIStruct(windowWidth, windowHeight int, window *widgets.QMainWindow) (loginUIStruct LoginUI) {
 -	configStruct := config{
 -		windowWidth:  windowWidth,
 -		windowHeight: windowHeight,
 +func NewLoginUIStruct(windowWidth, windowHeight int, window *widgets.QMainWindow) (loginUIStruct *LoginUI) {
 +	configStruct := globalTypes.Config{
 +		WindowWidth:  windowWidth,
 +		WindowHeight: windowHeight,
  	}
 -	loginUIStruct = LoginUI{
 -		config: configStruct,
 +	loginUIStruct = &LoginUI{
 +		Config: configStruct,
  		window: window,
  	}
  	return
  }
  
  // NewLoginUIStructWithExistingConfig gives you a LoginUI struct with prefilled data and data from a previous Config
 -func NewLoginUIStructWithExistingConfig(configStruct config, window *widgets.QMainWindow) (loginUIStruct LoginUI) {
 -	loginUIStruct = LoginUI{
 -		config: configStruct,
 +func NewLoginUIStructWithExistingConfig(configStruct globalTypes.Config, window *widgets.QMainWindow) (loginUIStruct *LoginUI) {
 +	loginUIStruct = &LoginUI{
 +		Config: configStruct,
  		window: window,
  	}
  	return
 @@ -77,35 +78,31 @@ func (l *LoginUI) NewUI() (err error) {
  		if usernameInput.StyleSheet() == "border: 1px solid red" {
  			usernameInput.SetStyleSheet("")
  		}
 -		l.username = value
 +		l.Username = value
  	})
  
  	passwordInput.ConnectTextChanged(func(value string) {
  		if passwordInput.StyleSheet() == "border: 1px solid red" {
  			passwordInput.SetStyleSheet("")
  		}
 -		l.password = value
 +		l.Password = value
  	})
  
  	loginButton.ConnectClicked(func(_ bool) {
 -		if l.username != "" {
 -			if l.password != "" {
 -				LoginErr := l.login()
 -				if LoginErr != nil {
 -					err = LoginErr
 -					return
 -				}
 -			} else {
 -				passwordInput.SetStyleSheet("border: 1px solid red")
 +		if l.Username != "" && l.Password != "" {
 +			LoginErr := l.login()
 +			if LoginErr != nil {
 +				err = LoginErr
 +				return
  			}
  		} else {
 -			usernameInput.SetStyleSheet("border: 1px solid red")
 +			passwordInput.SetStyleSheet("border: 1px solid red")
  		}
  	})
  
  	usernameInput.ConnectKeyPressEvent(func(ev *gui.QKeyEvent) {
  		if int(ev.Key()) == int(core.Qt__Key_Enter) || int(ev.Key()) == int(core.Qt__Key_Return) {
 -			if l.password != "" {
 +			if l.Password != "" {
  				LoginErr := l.login()
  				if LoginErr != nil {
  					err = LoginErr
 @@ -126,7 +123,7 @@ func (l *LoginUI) NewUI() (err error) {
  
  	passwordInput.ConnectKeyPressEvent(func(ev *gui.QKeyEvent) {
  		if int(ev.Key()) == int(core.Qt__Key_Enter) || int(ev.Key()) == int(core.Qt__Key_Return) {
 -			if l.username != "" {
 +			if l.Username != "" {
  				LoginErr := l.login()
  				if LoginErr != nil {
  					err = LoginErr
 @@ -155,12 +152,12 @@ func (l *LoginUI) login() (err error) {
  
  	var wg sync.WaitGroup
  
 -	if l.username != "" && l.password != "" {
 +	if l.Username != "" && l.Password != "" {
  		log.Infoln("Starting Login Sequenze in background")
  		results := make(chan *gomatrix.Client)
  
  		wg.Add(1)
 -		go matrix.DoLogin(l.username, l.password, "", "", "", results, &wg)
 +		go matrix.DoLogin(l.Username, l.Password, "", "", "", results, &wg)
  
  		go func() {
  			wg.Wait()      // wait for each execTask to return
 @@ -169,9 +166,8 @@ func (l *LoginUI) login() (err error) {
  
  		//Show MainUI
  		for result := range results {
 -			//TODO Don't switch screen on wrong login data.
 -			l.cli = result
 -			MainUIStruct := NewMainUIStructWithExistingConfig(l.config, l.window)
 +			l.Cli = result
 +			MainUIStruct := NewMainUIStructWithExistingConfig(l.Config, l.window)
  			mainUIErr := MainUIStruct.NewUI()
  			if mainUIErr != nil {
  				err = mainUIErr
 diff --git a/ui/MainUI.go b/ui/MainUI.go
 index a5f8cfa..fc818ad 100644
 --- a/ui/MainUI.go
 +++ b/ui/MainUI.go
 @@ -2,18 +2,24 @@ package ui
  
  import (
  	"fmt"
 +	"os"
 +	"path/filepath"
  	"strconv"
  	"strings"
  	"sync"
  
  	"github.com/Nordgedanken/Morpheus/matrix"
  	"github.com/Nordgedanken/Morpheus/matrix/db"
 +	"github.com/Nordgedanken/Morpheus/matrix/globalTypes"
 +	"github.com/Nordgedanken/Morpheus/matrix/rooms"
  	"github.com/Nordgedanken/Morpheus/matrix/syncer"
 +	"github.com/Nordgedanken/Morpheus/ui/listLayouts"
  	"github.com/dgraph-io/badger"
  	"github.com/matrix-org/gomatrix"
  	"github.com/opennota/linkify"
  	"github.com/pkg/errors"
  	"github.com/rhinoman/go-commonmark"
 +	"github.com/shibukawa/configdir"
  	log "github.com/sirupsen/logrus"
  	"github.com/therecipe/qt/core"
  	"github.com/therecipe/qt/gui"
 @@ -22,32 +28,32 @@ import (
  )
  
  // NewMainUIStruct gives you a MainUI struct with prefilled data
 -func NewMainUIStruct(windowWidth, windowHeight int, window *widgets.QMainWindow) (mainUIStruct MainUI) {
 -	configStruct := config{
 -		windowWidth:  windowWidth,
 -		windowHeight: windowHeight,
 +func NewMainUIStruct(windowWidth, windowHeight int, window *widgets.QMainWindow) (mainUIStruct *MainUI) {
 +	configStruct := globalTypes.Config{
 +		WindowWidth:  windowWidth,
 +		WindowHeight: windowHeight,
 +		Rooms:        make(map[string]*rooms.Room),
  	}
 -	mainUIStruct = MainUI{
 -		config: configStruct,
 +	mainUIStruct = &MainUI{
 +		Config: configStruct,
  		window: window,
 -		rooms:  make(map[string]*matrix.Room),
  	}
  	return
  }
  
  // NewMainUIStructWithExistingConfig gives you a MainUI struct with prefilled data and data from a previous Config
 -func NewMainUIStructWithExistingConfig(configStruct config, window *widgets.QMainWindow) (mainUIStruct MainUI) {
 -	mainUIStruct = MainUI{
 -		config: configStruct,
 +func NewMainUIStructWithExistingConfig(configStruct globalTypes.Config, window *widgets.QMainWindow) (mainUIStruct *MainUI) {
 +	configStruct.Rooms = make(map[string]*rooms.Room)
 +	mainUIStruct = &MainUI{
 +		Config: configStruct,
  		window: window,
 -		rooms:  make(map[string]*matrix.Room),
  	}
  	return
  }
  
  // SetCli allows you to add a gomatrix.Client to your MainUI struct
  func (m *MainUI) SetCli(cli *gomatrix.Client) {
 -	m.cli = cli
 +	m.Cli = cli
  }
  
  // GetWidget gives you the widget of the MainUI struct
 @@ -58,38 +64,11 @@ func (m *MainUI) GetWidget() (widget *widgets.QWidget) {
  
  // NewUI initializes a new Main Screen
  func (m *MainUI) NewUI() (err error) {
 -	m.widget = widgets.NewQWidget(nil, 0)
 -
 -	var loader = uitools.NewQUiLoader(nil)
 -	var file = core.NewQFile2(":/qml/ui/chat.ui")
 -
 -	file.Open(core.QIODevice__ReadOnly)
 -	m.MainWidget = loader.Load(file, m.widget)
 -	file.Close()
 -
 -	m.messageScrollArea = widgets.NewQScrollAreaFromPointer(m.widget.FindChild("messageScroll", core.Qt__FindChildrenRecursively).Pointer())
 -	messagesScrollAreaContent := widgets.NewQWidgetFromPointer(m.widget.FindChild("messagesScrollAreaContent", core.Qt__FindChildrenRecursively).Pointer())
 -	roomScrollArea := widgets.NewQScrollAreaFromPointer(m.widget.FindChild("roomScroll", core.Qt__FindChildrenRecursively).Pointer())
 -	roomScrollAreaContent := widgets.NewQWidgetFromPointer(m.widget.FindChild("roomScrollAreaContent", core.Qt__FindChildrenRecursively).Pointer())
 -
 -	m.RoomAvatar = widgets.NewQLabelFromPointer(m.widget.FindChild("roomAvatar", core.Qt__FindChildrenRecursively).Pointer())
 -	m.RoomTitle = widgets.NewQLabelFromPointer(m.widget.FindChild("RoomTitle", core.Qt__FindChildrenRecursively).Pointer())
 -	m.RoomTopic = widgets.NewQLabelFromPointer(m.widget.FindChild("Topic", core.Qt__FindChildrenRecursively).Pointer())
 -
 -	var layout = widgets.NewQHBoxLayout()
 -	m.window.SetLayout(layout)
 -	layout.InsertWidget(0, m.MainWidget, 0, core.Qt__AlignTop|core.Qt__AlignLeft)
 -	layout.SetSpacing(0)
 -	layout.SetContentsMargins(0, 0, 0, 0)
 -
 -	m.widget.ConnectResizeEvent(func(event *gui.QResizeEvent) {
 -		m.MainWidget.Resize(event.Size())
 -		event.Accept()
 -	})
 +	m.loadChatUIDefaults()
  
  	//Set Avatar
  	avatarLogo := widgets.NewQLabelFromPointer(m.widget.FindChild("UserAvatar", core.Qt__FindChildrenRecursively).Pointer())
 -	avatar, AvatarErr := matrix.GetOwnUserAvatar(m.cli)
 +	avatar, AvatarErr := matrix.GetOwnUserAvatar(m.Cli)
  	if AvatarErr != nil {
  		err = AvatarErr
  		return
 @@ -106,25 +85,12 @@ func (m *MainUI) NewUI() (err error) {
  		}
  	})
  
 -	// Init Message View
 -	m.MessageListLayout = NewMessageList(m.messageScrollArea, messagesScrollAreaContent)
 -
 -	// Init Room View
 -	roomListLayout := NewRoomList(roomScrollArea, roomScrollAreaContent)
 -
 -	m.messageScrollArea.SetWidgetResizable(true)
 -	m.messageScrollArea.SetHorizontalScrollBarPolicy(core.Qt__ScrollBarAlwaysOff)
 -	m.messageScrollArea.SetContentsMargins(0, 0, 0, 0)
 -	//messageScrollArea.SetSizeAdjustPolicy(widgets.QAbstractScrollArea__AdjustToContents)
 -
 -	roomScrollArea.SetWidgetResizable(true)
 -	roomScrollArea.SetHorizontalScrollBarPolicy(core.Qt__ScrollBarAlwaysOff)
 -	roomScrollArea.SetContentsMargins(0, 0, 0, 0)
 -	roomScrollArea.SetSizeAdjustPolicy(widgets.QAbstractScrollArea__AdjustToContents)
 +	m.initScrolls()
  
  	m.MessageListLayout.ConnectTriggerMessage(func(messageBody, sender string, timestamp int64) {
 +		log.Println("triggered Message")
  		var own bool
 -		if sender == m.cli.UserID {
 +		if sender == m.Cli.UserID {
  			own = true
  		} else {
  			own = false
 @@ -152,43 +118,24 @@ func (m *MainUI) NewUI() (err error) {
  				}
  			}
  		}
 -		NewMessageErr := m.MessageListLayout.NewMessage(messageBody, m.cli, sender, timestamp, m.messageScrollArea, own, m)
 -		if NewMessageErr != nil {
 -			err = NewMessageErr
 -			return
 -		}
 +		m.MessageListLayout.NewMessage(messageBody, m.Cli, sender, timestamp, m.messageScrollArea, own)
  	})
  
 -	m.startSync()
 +	go m.startSync()
  	m.widget.SetSizePolicy2(widgets.QSizePolicy__Expanding, widgets.QSizePolicy__Expanding)
  	m.MainWidget.SetSizePolicy2(widgets.QSizePolicy__Expanding, widgets.QSizePolicy__Expanding)
  
 -	roomListLayout.ConnectTriggerRoom(func(roomID string) {
 -		room := m.rooms[roomID]
 +	m.RoomListLayout.ConnectTriggerRoom(func(roomID string) {
 +		room := m.Rooms[roomID]
  
 -		NewRoomErr := roomListLayout.NewRoom(room, roomScrollArea, m)
 +		NewRoomErr := m.RoomListLayout.NewRoom(room, m.roomScrollArea)
  		if NewRoomErr != nil {
  			err = NewRoomErr
  			return
  		}
  	})
  
 -	m.initRoomList(roomListLayout, roomScrollArea)
 -
 -	go m.loadCache()
 -
 -	m.MainWidget.SetWindowTitle("Morpheus - " + m.rooms[m.currentRoom].GetRoomTopic())
 -
 -	avatar, roomAvatarErr := m.rooms[m.currentRoom].GetRoomAvatar()
 -	if roomAvatarErr != nil {
 -		err = roomAvatarErr
 -		return
 -	}
 -	m.RoomAvatar.SetPixmap(avatar)
 -
 -	m.RoomTitle.SetText(m.rooms[m.currentRoom].GetRoomName())
 -
 -	m.RoomTopic.SetText(m.rooms[m.currentRoom].GetRoomTopic())
 +	go m.initRoomList()
  
  	var message string
  	messageInput := widgets.NewQLineEditFromPointer(m.widget.FindChild("MessageInput", core.Qt__FindChildrenRecursively).Pointer())
 @@ -198,11 +145,7 @@ func (m *MainUI) NewUI() (err error) {
  
  	m.window.ConnectKeyPressEvent(func(ev *gui.QKeyEvent) {
  		if int(ev.Key()) == int(core.Qt__Key_Enter) || int(ev.Key()) == int(core.Qt__Key_Return) {
 -			MessageErr := m.sendMessage(message)
 -			if MessageErr != nil {
 -				err = MessageErr
 -				return
 -			}
 +			go m.sendMessage(message)
  
  			messageInput.Clear()
  			ev.Accept()
 @@ -210,11 +153,84 @@ func (m *MainUI) NewUI() (err error) {
  			messageInput.KeyPressEventDefault(ev)
  			ev.Ignore()
  		}
 +		return
 +	})
 +
 +	m.RoomListLayout.ConnectChangeRoom(func(roomID string) {
 +		room := m.Rooms[roomID]
 +		roomAvatar, roomAvatarErr := room.GetRoomAvatar()
 +		if roomAvatarErr != nil {
 +			err = roomAvatarErr
 +			return
 +		}
 +		if m.CurrentRoom != room.RoomID {
 +			m.SetCurrentRoom(room.RoomID)
 +			m.MainWidget.SetWindowTitle("Morpheus - " + room.GetRoomTopic())
 +
 +			m.RoomAvatar.SetPixmap(roomAvatar)
 +
 +			m.RoomTitle.SetText(room.GetRoomName())
 +
 +			m.RoomTopic.SetText(room.GetRoomTopic())
 +			count := m.MessageListLayout.Count()
 +			for i := 0; i < count; i++ {
 +				widgetScroll := m.MessageListLayout.ItemAt(i).Widget()
 +				widgetScroll.DeleteLater()
 +			}
 +
 +			log.Println("next loadCache")
 +			go m.loadCache()
 +		}
  	})
  
  	return
  }
  
 +func (m *MainUI) initScrolls() {
 +	// Init Message View
 +	m.MessageListLayout = listLayouts.NewMessageList(m.messageScrollArea)
 +
 +	// Init Room View
 +	m.RoomListLayout = listLayouts.NewRoomList(m.roomScrollArea)
 +
 +	m.messageScrollArea.SetWidgetResizable(true)
 +	m.messageScrollArea.SetHorizontalScrollBarPolicy(core.Qt__ScrollBarAlwaysOff)
 +	m.messageScrollArea.SetContentsMargins(0, 0, 0, 0)
 +
 +	m.roomScrollArea.SetWidgetResizable(true)
 +	m.roomScrollArea.SetHorizontalScrollBarPolicy(core.Qt__ScrollBarAlwaysOff)
 +	m.roomScrollArea.SetContentsMargins(0, 0, 0, 0)
 +}
 +
 +func (m *MainUI) loadChatUIDefaults() {
 +	m.widget = widgets.NewQWidget(nil, 0)
 +
 +	var loader = uitools.NewQUiLoader(nil)
 +	var file = core.NewQFile2(":/qml/ui/chat.ui")
 +
 +	file.Open(core.QIODevice__ReadOnly)
 +	m.MainWidget = loader.Load(file, m.widget)
 +	file.Close()
 +
 +	m.messageScrollArea = widgets.NewQScrollAreaFromPointer(m.widget.FindChild("messageScroll", core.Qt__FindChildrenRecursively).Pointer())
 +	m.roomScrollArea = widgets.NewQScrollAreaFromPointer(m.widget.FindChild("roomScroll", core.Qt__FindChildrenRecursively).Pointer())
 +
 +	m.RoomAvatar = widgets.NewQLabelFromPointer(m.widget.FindChild("roomAvatar", core.Qt__FindChildrenRecursively).Pointer())
 +	m.RoomTitle = widgets.NewQLabelFromPointer(m.widget.FindChild("RoomTitle", core.Qt__FindChildrenRecursively).Pointer())
 +	m.RoomTopic = widgets.NewQLabelFromPointer(m.widget.FindChild("Topic", core.Qt__FindChildrenRecursively).Pointer())
 +
 +	var layout = widgets.NewQHBoxLayout()
 +	m.window.SetLayout(layout)
 +	layout.InsertWidget(0, m.MainWidget, 0, core.Qt__AlignTop|core.Qt__AlignLeft)
 +	layout.SetSpacing(0)
 +	layout.SetContentsMargins(0, 0, 0, 0)
 +
 +	m.widget.ConnectResizeEvent(func(event *gui.QResizeEvent) {
 +		m.MainWidget.Resize(event.Size())
 +		event.Accept()
 +	})
 +}
 +
  func (m *MainUI) sendMessage(message string) (err error) {
  	messageOriginal := message
  	lm := linkify.Links(message)
 @@ -225,13 +241,13 @@ func (m *MainUI) sendMessage(message string) (err error) {
  
  	mardownMessage := commonmark.Md2Html(message, 0)
  	if mardownMessage == message {
 -		_, SendErr := m.cli.SendMessageEvent(m.currentRoom, "m.room.message", matrix.HTMLMessage{MsgType: "m.text", Body: messageOriginal, FormattedBody: message, Format: "org.matrix.custom.html"})
 +		_, SendErr := m.Cli.SendMessageEvent(m.CurrentRoom, "m.room.message", matrix.HTMLMessage{MsgType: "m.text", Body: messageOriginal, FormattedBody: message, Format: "org.matrix.custom.html"})
  		if SendErr != nil {
  			err = SendErr
  			return
  		}
  	} else {
 -		_, SendErr := m.cli.SendMessageEvent(m.currentRoom, "m.room.message", matrix.HTMLMessage{MsgType: "m.text", Body: message, FormattedBody: mardownMessage, Format: "org.matrix.custom.html"})
 +		_, SendErr := m.Cli.SendMessageEvent(m.CurrentRoom, "m.room.message", matrix.HTMLMessage{MsgType: "m.text", Body: message, FormattedBody: mardownMessage, Format: "org.matrix.custom.html"})
  		if SendErr != nil {
  			err = SendErr
  			return
 @@ -241,7 +257,6 @@ func (m *MainUI) sendMessage(message string) (err error) {
  }
  
  func (m *MainUI) logout(widget *widgets.QWidget, messageScrollArea *widgets.QScrollArea) (err error) {
 -	//TODO register enter and show loader or so
  	log.Infoln("Starting Logout Sequence in background")
  	var wg sync.WaitGroup
  	results := make(chan bool)
 @@ -249,6 +264,7 @@ func (m *MainUI) logout(widget *widgets.QWidget, messageScrollArea *widgets.QScr
  	wg.Add(1)
  	go func(cli *gomatrix.Client, results chan<- bool) {
  		defer wg.Done()
 +		cli.StopSync()
  		_, LogoutErr := cli.Logout()
  		if LogoutErr != nil {
  			log.Errorln(LogoutErr)
 @@ -260,29 +276,18 @@ func (m *MainUI) logout(widget *widgets.QWidget, messageScrollArea *widgets.QScr
  		if DBOpenErr != nil {
  			log.Errorln(DBOpenErr)
  		}
 +		userDB.Close()
  
 -		//Flush complete DB
 -		txn := userDB.NewTransaction(true) // Read-write txn
 -		QueryErr := txn.Delete([]byte(""))
 -		if QueryErr != nil {
 -			log.Errorln(QueryErr)
 -			results <- false
 -		}
 -
 -		CommitErr := txn.Commit(nil)
 -		if CommitErr != nil {
 -			log.Errorln(CommitErr)
 +		configDirs := configdir.New("Nordgedanken", "Morpheus")
 +		filePath := filepath.ToSlash(configDirs.QueryFolders(configdir.Global)[0].Path)
 +		DeleteErr := os.RemoveAll(filePath + "/data/user/")
 +		if DeleteErr != nil {
 +			log.Errorln(DeleteErr)
  			results <- false
  		}
 -
 -		DBPurgeErr := userDB.PurgeOlderVersions()
 -		if DBPurgeErr != nil {
 -			log.Errorln(DBPurgeErr)
 -			results <- false
 -		} else {
 -			results <- true
 -		}
 -	}(m.cli, results)
 +		db.ResetOnceUser()
 +		results <- true
 +	}(m.Cli, results)
  
  	go func() {
  		wg.Wait()      // wait for each execTask to return
 @@ -297,7 +302,7 @@ func (m *MainUI) logout(widget *widgets.QWidget, messageScrollArea *widgets.QScr
  			widget.DisconnectResizeEvent()
  			messageScrollArea.DisconnectResizeEvent()
  
 -			LoginUIStruct := NewLoginUIStructWithExistingConfig(m.config, m.window)
 +			LoginUIStruct := NewLoginUIStructWithExistingConfig(m.Config, m.window)
  			loginUIErr := LoginUIStruct.NewUI()
  			if loginUIErr != nil {
  				err = loginUIErr
 @@ -321,16 +326,16 @@ func (m *MainUI) startSync() (err error) {
  	})
  	m.storage = &syncer.MorpheusStore{
  		InMemoryStore: *gomatrix.NewInMemoryStore(),
 -		CacheDatabase: m.cacheDB,
 +		CacheDatabase: m.CacheDB,
  	}
  
 -	m.syncer = syncer.NewMorpheusSyncer(m.cli.UserID, m.storage)
 +	Syncer := syncer.NewMorpheusSyncer(m.Cli.UserID, m.storage)
  
 -	m.cli.Store = m.storage
 -	m.cli.Syncer = m.syncer
 -	m.syncer.Store = m.storage
 +	m.Cli.Store = m.storage
 +	m.Cli.Syncer = Syncer
 +	Syncer.Store = m.storage
  
 -	m.syncer.OnEventType("m.room.message", func(ev *gomatrix.Event) {
 +	Syncer.OnEventType("m.room.message", func(ev *gomatrix.Event) {
  		formattedBody, _ := ev.Content["formatted_body"]
  		var msg string
  		msg, _ = formattedBody.(string)
 @@ -342,17 +347,38 @@ func (m *MainUI) startSync() (err error) {
  		id := ev.ID
  		timestamp := ev.Timestamp
  		go db.CacheMessageEvents(id, sender, room, msg, timestamp)
 -		if room == m.currentRoom {
 +		if room == m.CurrentRoom {
  			go m.MessageListLayout.TriggerMessage(msg, sender, timestamp)
  		}
  	})
  
 +	Syncer.OnEventType("m.room.name", func(ev *gomatrix.Event) {
 +		roomNameRaw, _ := ev.Content["name"]
 +		var roomName string
 +		roomName, _ = roomNameRaw.(string)
 +		evType := ev.Type
 +		room := ev.RoomID
 +		go m.Rooms[room].UpdateRoomNameByEvent(roomName, evType)
 +	})
 +
 +	Syncer.OnEventType("m.room.name", func(ev *gomatrix.Event) {
 +		roomNameRaw, _ := ev.Content["name"]
 +		var roomName string
 +		roomName, _ = roomNameRaw.(string)
 +		evType := ev.Type
 +		room := ev.RoomID
 +		go m.Rooms[room].UpdateRoomNameByEvent(roomName, evType)
 +	})
 +
  	// Start Non-blocking sync
  	go func() {
  		log.Infoln("Start sync")
  		for {
 -
 -			if e := m.cli.Sync(); e != nil {
 +			e := m.Cli.Sync()
 +			if e == nil {
 +				break
 +			}
 +			if e != nil {
  				err = e
  			}
  		}
 @@ -360,21 +386,21 @@ func (m *MainUI) startSync() (err error) {
  	return
  }
  
 -func (m *MainUI) initRoomList(roomListLayout *QRoomVBoxLayoutWithTriggerSlot, roomScrollArea *widgets.QScrollArea) (err error) {
 -	rooms, ReqErr := m.cli.JoinedRooms()
 -	if ReqErr != nil {
 -		err = ReqErr
 +func (m *MainUI) initRoomList() (err error) {
 +	roomsStruct, roomsErr := rooms.GetRooms(m.Cli)
 +	if roomsErr != nil {
 +		err = roomsErr
  		return
  	}
  
 -	x := 0
 -	for _, roomID := range rooms.JoinedRooms {
 -		if x == 0 {
 -			m.currentRoom = roomID
 +	first := true
 +	for _, roomID := range roomsStruct {
 +		m.Rooms[roomID] = rooms.NewRoom(roomID, m.Cli)
 +		m.RoomListLayout.TriggerRoom(roomID)
 +		if first {
 +			go m.RoomListLayout.ChangeRoom(roomID)
  		}
 -		x++
 -		m.rooms[roomID] = matrix.NewRoom(roomID, m.cli)
 -		roomListLayout.TriggerRoom(roomID)
 +		first = false
  	}
  
  	return
 @@ -406,7 +432,7 @@ func (m *MainUI) loadCache() (err error) {
  		MsgOpts := badger.DefaultIteratorOptions
  		MsgOpts.PrefetchSize = 10
  		MsgIt := txn.NewIterator(MsgOpts)
 -		MsgPrefix := []byte("room|" + m.currentRoom + "|messages|")
 +		MsgPrefix := []byte("room|" + m.CurrentRoom + "|messages")
  
  		var doneMsg []string
  
 @@ -414,203 +440,47 @@ func (m *MainUI) loadCache() (err error) {
  			item := MsgIt.Item()
  			key := item.Key()
  			stringKey := fmt.Sprintf("%s", key)
 +			stringKeySlice := strings.Split(stringKey, "|")
 +			stringKeyEnd := stringKeySlice[len(stringKeySlice)-1]
 +			if stringKeyEnd != "id" {
 +				continue
 +			}
 +
  			value, ValueErr := item.Value()
  			if ValueErr != nil {
  				return ValueErr
  			}
 -			stringValue := fmt.Sprintf("%s", value)
 -
 -			if strings.HasSuffix(stringKey, "|id") {
 -				if !contains(doneMsg, stringValue) {
 -					// Remember we already added this message to the view
 -					doneMsg = append(doneMsg, stringValue)
 -
 -					// Get all Data
 -					senderItem, senderErr := txn.Get([]byte(strings.Replace(stringKey, "|id", "|sender", -1)))
 -					if senderErr != nil {
 -						return errors.WithMessage(senderErr, "Key: "+strings.Replace(stringKey, "|id", "|sender", -1))
 -					}
 -
 -					senderValue, senderValueErr := senderItem.Value()
 -					if senderValueErr != nil {
 -						return senderValueErr
 -					}
 -					sender := fmt.Sprintf("%s", senderValue)
 -
 -					messageItem, messageErr := txn.Get([]byte(strings.Replace(stringKey, "|id", "|messageString", -1)))
 -					if messageErr != nil {
 -						return errors.WithMessage(messageErr, "Key: "+strings.Replace(stringKey, "|id", "|messageString", -1))
 -					}
 -
 -					messageValue, messageValueErr := messageItem.Value()
 -					if messageValueErr != nil {
 -						return messageValueErr
 -					}
 -					msg := fmt.Sprintf("%s", messageValue)
 -
 -					timestampItem, timestampErr := txn.Get([]byte(strings.Replace(stringKey, "|id", "|timestamp", -1)))
 -					if timestampErr != nil {
 -						return errors.WithMessage(timestampErr, "Key: "+strings.Replace(stringKey, "|id", "|timestamp", -1))
 -					}
 -
 -					timestampValue, timestampValueErr := timestampItem.Value()
 -					if timestampValueErr != nil {
 -						return timestampValueErr
 -					}
 -					timestamp := fmt.Sprintf("%s", timestampValue)
 -					timestampInt, ConvErr := strconv.ParseInt(timestamp, 10, 64)
 -					if ConvErr != nil {
 -						return ConvErr
 -					}
 -
 -					m.MessageListLayout.TriggerMessage(msg, sender, timestampInt)
 -				}
 -			}
 +			idValue := fmt.Sprintf("%s", value)
  
 -			if strings.HasSuffix(stringKey, "|sender") {
 -				idItem, idErr := txn.Get([]byte(strings.Replace(stringKey, "|sender", "|id", -1)))
 -				if idErr != nil {
 -					return errors.WithMessage(idErr, "Key: "+strings.Replace(stringKey, "|sender", "|id", -1))
 -				}
 -				idValue, idValueErr := idItem.Value()
 -				if idValueErr != nil {
 -					return idValueErr
 -				}
 -				id := fmt.Sprintf("%s", idValue)
 -
 -				if !contains(doneMsg, id) {
 -					// Remember we already added this message to the view
 -					doneMsg = append(doneMsg, id)
 -
 -					// Get all Data
 -					sender := stringValue
 -
 -					messageItem, messageErr := txn.Get([]byte(strings.Replace(stringKey, "|sender", "|messageString", -1)))
 -					if messageErr != nil {
 -						return errors.WithMessage(messageErr, "Key: "+strings.Replace(stringKey, "|sender", "|messageString", -1))
 -					}
 +			if !contains(doneMsg, idValue) {
 +				// Remember we already added this message to the view
 +				doneMsg = append(doneMsg, idValue)
  
 -					messageValue, messageValueErr := messageItem.Value()
 -					if messageValueErr != nil {
 -						return messageValueErr
 -					}
 -					msg := fmt.Sprintf("%s", messageValue)
 -
 -					timestampItem, timestampErr := txn.Get([]byte(strings.Replace(stringKey, "|sender", "|timestamp", -1)))
 -					if timestampErr != nil {
 -						return errors.WithMessage(timestampErr, "Key: "+strings.Replace(stringKey, "|sender", "|timestamp", -1))
 -					}
 -
 -					timestampValue, timestampValueErr := timestampItem.Value()
 -					if timestampValueErr != nil {
 -						return timestampValueErr
 -					}
 -					timestamp := fmt.Sprintf("%s", timestampValue)
 -
 -					timestampInt, ConvErr := strconv.ParseInt(timestamp, 10, 64)
 -					if ConvErr != nil {
 -						return ConvErr
 -					}
 -
 -					m.MessageListLayout.TriggerMessage(msg, sender, timestampInt)
 -				}
 -			}
 -
 -			if strings.HasSuffix(stringKey, "|messageString") {
 -				idItem, idErr := txn.Get([]byte(strings.Replace(stringKey, "|messageString", "|id", -1)))
 -				if idErr != nil {
 -					return errors.WithMessage(idErr, "Key: "+strings.Replace(stringKey, "|messageString", "|id", -1))
 +				// Get all Data
 +				senderResult, QueryErr := db.Get(txn, []byte(strings.Replace(stringKey, "|id", "|sender", -1)))
 +				if QueryErr != nil {
 +					return errors.WithMessage(QueryErr, "Key: "+strings.Replace(stringKey, "|id", "|sender", -1))
  				}
 +				sender := fmt.Sprintf("%s", senderResult)
  
 -				idValue, idValueErr := idItem.Value()
 -				if idValueErr != nil {
 -					return idValueErr
 +				msgResult, QueryErr := db.Get(txn, []byte(strings.Replace(stringKey, "|id", "|messageString", -1)))
 +				if QueryErr != nil {
 +					return errors.WithMessage(QueryErr, "Key: "+strings.Replace(stringKey, "|id", "|messageString", -1))
  				}
 -				id := fmt.Sprintf("%s", idValue)
 -
 -				if !contains(doneMsg, id) {
 -					// Remember we already added this message to the view
 -					doneMsg = append(doneMsg, id)
 -
 -					// Get all Data
 -					senderItem, senderErr := txn.Get([]byte(strings.Replace(stringKey, "|messageString", "|sender", -1)))
 -					if senderErr != nil {
 -						return errors.WithMessage(senderErr, "Key: "+strings.Replace(stringKey, "|messageString", "|sender", -1))
 -					}
 -
 -					senderValue, senderValueErr := senderItem.Value()
 -					if senderValueErr != nil {
 -						return senderValueErr
 -					}
 -					sender := fmt.Sprintf("%s", senderValue)
 -
 -					msg := stringValue
 -
 -					timestampItem, timestampErr := txn.Get([]byte(strings.Replace(stringKey, "|messageString", "|timestamp", -1)))
 -					if timestampErr != nil {
 -						return errors.WithMessage(timestampErr, "Key: "+strings.Replace(stringKey, "|messageString", "|timestamp", -1))
 -					}
 -
 -					timestampValue, timestampValueErr := timestampItem.Value()
 -					if timestampValueErr != nil {
 -						return timestampValueErr
 -					}
 -					timestamp := fmt.Sprintf("%s", timestampValue)
 +				msg := fmt.Sprintf("%s", msgResult)
  
 -					timestampInt, ConvErr := strconv.ParseInt(timestamp, 10, 64)
 -					if ConvErr != nil {
 -						return ConvErr
 -					}
 -
 -					m.MessageListLayout.TriggerMessage(msg, sender, timestampInt)
 +				timestampResult, QueryErr := db.Get(txn, []byte(strings.Replace(stringKey, "|id", "|timestamp", -1)))
 +				if QueryErr != nil {
 +					return errors.WithMessage(QueryErr, "Key: "+strings.Replace(stringKey, "|id", "|timestamp", -1))
  				}
 -			}
 +				timestamp := fmt.Sprintf("%s", timestampResult)
  
 -			if strings.HasSuffix(stringKey, "|timestamp") {
 -				idItem, idErr := txn.Get([]byte(strings.Replace(stringKey, "|timestamp", "|id", -1)))
 -				if idErr != nil {
 -					return errors.WithMessage(idErr, "Key: "+strings.Replace(stringKey, "|timestamp", "|id", -1))
 +				timestampInt, ConvErr := strconv.ParseInt(timestamp, 10, 64)
 +				if ConvErr != nil {
 +					return errors.WithMessage(ConvErr, "Timestamp String: "+timestamp)
  				}
 -				idValue, idValueErr := idItem.Value()
 -				if idValueErr != nil {
 -					return idValueErr
 -				}
 -				id := fmt.Sprintf("%s", idValue)
 -
 -				if !contains(doneMsg, id) {
 -					// Remember we already added this message to the view
 -					doneMsg = append(doneMsg, id)
  
 -					// Get all Data
 -					senderItem, senderErr := txn.Get([]byte(strings.Replace(stringKey, "|timestamp", "|sender", -1)))
 -					if senderErr != nil {
 -						return errors.WithMessage(senderErr, "Key: "+strings.Replace(stringKey, "|timestamp", "|sender", -1))
 -					}
 -					senderValue, senderValueErr := senderItem.Value()
 -					if senderValueErr != nil {
 -						return senderValueErr
 -					}
 -					sender := fmt.Sprintf("%s", senderValue)
 -
 -					messageItem, messageErr := txn.Get([]byte(strings.Replace(stringKey, "|timestamp", "|messageString", -1)))
 -					if messageErr != nil {
 -						return errors.WithMessage(messageErr, "Key: "+strings.Replace(stringKey, "|timestamp", "|messageString", -1))
 -					}
 -					messageValue, messageValueErr := messageItem.Value()
 -					if messageValueErr != nil {
 -						return messageValueErr
 -					}
 -					msg := fmt.Sprintf("%s", messageValue)
 -
 -					timestamp := stringValue
 -
 -					timestampInt, ConvErr := strconv.ParseInt(timestamp, 10, 64)
 -					if ConvErr != nil {
 -						return ConvErr
 -					}
 -
 -					m.MessageListLayout.TriggerMessage(msg, sender, timestampInt)
 -				}
 +				go m.MessageListLayout.TriggerMessage(msg, sender, timestampInt)
  			}
  		}
  
 @@ -623,6 +493,7 @@ func (m *MainUI) loadCache() (err error) {
  	}
  
  	if barAtBottom {
 +		bar.Update()
  		bar.SetValue(bar.Maximum())
  	}
  
 diff --git a/ui/messageList.go b/ui/listLayouts/messageList.go
 similarity index 80%
 rename from ui/messageList.go
 rename to ui/listLayouts/messageList.go
 index e5a3c6c..90a6a6b 100644
 --- a/ui/messageList.go
 +++ b/ui/listLayouts/messageList.go
 @@ -1,4 +1,4 @@
 -package ui
 +package listLayouts
  
  import (
  	"time"
 @@ -6,7 +6,9 @@ import (
  	"github.com/Nordgedanken/Morpheus/matrix"
  	"github.com/matrix-org/gomatrix"
  	"github.com/rhinoman/go-commonmark"
 +	log "github.com/sirupsen/logrus"
  	"github.com/therecipe/qt/core"
 +	"github.com/therecipe/qt/gui"
  	"github.com/therecipe/qt/uitools"
  	"github.com/therecipe/qt/widgets"
  )
 @@ -26,17 +28,17 @@ import (
  type QVBoxLayoutWithTriggerSlot struct {
  	widgets.QVBoxLayout
  
 -	_ func(messageBody, sender string, timestamp int64) `slot:"TriggerMessage"`
 +	_ func(messageBody, sender string, timestamp int64) `signal:"TriggerMessage"`
  }
  
  // NewMessageList generates a new QVBoxLayoutWithTriggerSlot and adds it to the message scrollArea
 -func NewMessageList(scrollArea *widgets.QScrollArea, messageView *widgets.QWidget) (messageViewLayout *QVBoxLayoutWithTriggerSlot) {
 -	messageViewLayout = NewQVBoxLayoutWithTriggerSlot2(messageView)
 +func NewMessageList(scrollArea *widgets.QScrollArea) (messageViewLayout *QVBoxLayoutWithTriggerSlot) {
 +	messageViewLayout = NewQVBoxLayoutWithTriggerSlot2(scrollArea.Widget())
  
  	messageViewLayout.SetSpacing(0)
 -	messageViewLayout.SetContentsMargins(0, 0, 0, 0)
 -	messageView.SetContentsMargins(0, 0, 0, 0)
 -	scrollArea.SetWidget(messageView)
 +	messageViewLayout.AddStretch(1)
 +	messageViewLayout.SetContentsMargins(15, 0, 15, 15)
 +	scrollArea.Widget().SetContentsMargins(0, 0, 0, 0)
  	scrollArea.SetAlignment(core.Qt__AlignLeading | core.Qt__AlignLeft | core.Qt__AlignVCenter)
  	scrollArea.Widget().SetLayout(messageViewLayout)
  
 @@ -44,7 +46,7 @@ func NewMessageList(scrollArea *widgets.QScrollArea, messageView *widgets.QWidge
  }
  
  // NewMessage adds a new message object to the view
 -func (messageViewLayout *QVBoxLayoutWithTriggerSlot) NewMessage(body string, cli *gomatrix.Client, sender string, timestamp int64, scrollArea *widgets.QScrollArea, own bool, mainUIStruct *MainUI) (err error) {
 +func (messageViewLayout *QVBoxLayoutWithTriggerSlot) NewMessage(body string, cli *gomatrix.Client, sender string, timestamp int64, scrollArea *widgets.QScrollArea, own bool) (err error) {
  	barAtBottom := false
  	bar := scrollArea.VerticalScrollBar()
  	if bar.Value() == bar.Maximum() {
 @@ -94,6 +96,21 @@ func (messageViewLayout *QVBoxLayoutWithTriggerSlot) NewMessage(body string, cli
  	}
  	senderContent.SetText(senderDisplayName)
  	timestampContent.SetText(timestampString)
 +
 +	avatarNew := gui.NewQPixmap()
 +	avatarLogo.ConnectPaintEvent(func(event *gui.QPaintEvent) {
 +		log.Println("PaintEventAvatar")
 +		painter := gui.NewQPainter2(avatarLogo)
 +
 +		aWidth := 61 / 2
 +		aHeight := 61 / 2
 +
 +		painter.DrawEllipse3(aWidth, aHeight, 61.0, 61.0)
 +		painter.DrawPixmap2(avatarLogo.Rect(), avatarNew, avatar.Rect())
 +		//avatarLogo.Update()
 +		avatarLogo.SetPixmap(avatarNew)
 +	})
 +
  	avatarLogo.SetPixmap(avatar)
  
  	var lineLength int
 diff --git a/ui/listLayouts/moc.cpp b/ui/listLayouts/moc.cpp
 new file mode 100644
 index 0000000..72b0ed7
 --- /dev/null
 +++ b/ui/listLayouts/moc.cpp
 @@ -0,0 +1,706 @@
 +
 +
 +#define protected public
 +#define private public
 +
 +#include "moc.h"
 +#include "_cgo_export.h"
 +
 +#include <QByteArray>
 +#include <QChildEvent>
 +#include <QEvent>
 +#include <QLayout>
 +#include <QLayoutItem>
 +#include <QList>
 +#include <QMetaMethod>
 +#include <QObject>
 +#include <QRect>
 +#include <QSize>
 +#include <QSizePolicy>
 +#include <QSpacerItem>
 +#include <QString>
 +#include <QTime>
 +#include <QTimer>
 +#include <QTimerEvent>
 +#include <QVBoxLayout>
 +#include <QWidget>
 +
 +
 +class QRoomVBoxLayoutWithTriggerSlot: public QVBoxLayout
 +{
 +Q_OBJECT
 +public:
 +	QRoomVBoxLayoutWithTriggerSlot() : QVBoxLayout() {qRegisterMetaType<quintptr>("quintptr");QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType();QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaTypes();callbackQRoomVBoxLayoutWithTriggerSlot_Constructor(this);};
 +	QRoomVBoxLayoutWithTriggerSlot(QWidget *parent) : QVBoxLayout(parent) {qRegisterMetaType<quintptr>("quintptr");QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType();QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaTypes();callbackQRoomVBoxLayoutWithTriggerSlot_Constructor(this);};
 +	void Signal_TriggerRoom(QString roomID) { QByteArray tdf131c = roomID.toUtf8(); Moc_PackedString roomIDPacked = { const_cast<char*>(tdf131c.prepend("WHITESPACE").constData()+10), tdf131c.size()-10 };callbackQRoomVBoxLayoutWithTriggerSlot_TriggerRoom(this, roomIDPacked); };
 +	void Signal_ChangeRoom(QString roomID) { QByteArray tdf131c = roomID.toUtf8(); Moc_PackedString roomIDPacked = { const_cast<char*>(tdf131c.prepend("WHITESPACE").constData()+10), tdf131c.size()-10 };callbackQRoomVBoxLayoutWithTriggerSlot_ChangeRoom(this, roomIDPacked); };
 +	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQRoomVBoxLayoutWithTriggerSlot_TakeAt(this, index)); };
 +	void addItem(QLayoutItem * item) { callbackQRoomVBoxLayoutWithTriggerSlot_AddItem(this, item); };
 +	void invalidate() { callbackQRoomVBoxLayoutWithTriggerSlot_Invalidate(this); };
 +	void setGeometry(const QRect & r) { callbackQRoomVBoxLayoutWithTriggerSlot_SetGeometry(this, const_cast<QRect*>(&r)); };
 +	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQRoomVBoxLayoutWithTriggerSlot_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
 +	QSize maximumSize() const { return *static_cast<QSize*>(callbackQRoomVBoxLayoutWithTriggerSlot_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
 +	QSize minimumSize() const { return *static_cast<QSize*>(callbackQRoomVBoxLayoutWithTriggerSlot_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
 +	QSize sizeHint() const { return *static_cast<QSize*>(callbackQRoomVBoxLayoutWithTriggerSlot_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
 +	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQRoomVBoxLayoutWithTriggerSlot_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
 +	bool hasHeightForWidth() const { return callbackQRoomVBoxLayoutWithTriggerSlot_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
 +	int count() const { return callbackQRoomVBoxLayoutWithTriggerSlot_Count(const_cast<void*>(static_cast<const void*>(this))); };
 +	int heightForWidth(int w) const { return callbackQRoomVBoxLayoutWithTriggerSlot_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
 +	int minimumHeightForWidth(int w) const { return callbackQRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
 +	QLayout * layout() { return static_cast<QLayout*>(callbackQRoomVBoxLayoutWithTriggerSlot_Layout(this)); };
 +	void childEvent(QChildEvent * e) { callbackQRoomVBoxLayoutWithTriggerSlot_ChildEvent(this, e); };
 +	QRect geometry() const { return *static_cast<QRect*>(callbackQRoomVBoxLayoutWithTriggerSlot_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
 +	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQRoomVBoxLayoutWithTriggerSlot_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
 +	bool isEmpty() const { return callbackQRoomVBoxLayoutWithTriggerSlot_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
 +	int indexOf(QWidget * widget) const { return callbackQRoomVBoxLayoutWithTriggerSlot_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
 +	bool event(QEvent * e) { return callbackQRoomVBoxLayoutWithTriggerSlot_Event(this, e) != 0; };
 +	bool eventFilter(QObject * watched, QEvent * event) { return callbackQRoomVBoxLayoutWithTriggerSlot_EventFilter(this, watched, event) != 0; };
 +	void connectNotify(const QMetaMethod & sign) { callbackQRoomVBoxLayoutWithTriggerSlot_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
 +	void customEvent(QEvent * event) { callbackQRoomVBoxLayoutWithTriggerSlot_CustomEvent(this, event); };
 +	void deleteLater() { callbackQRoomVBoxLayoutWithTriggerSlot_DeleteLater(this); };
 +	void Signal_Destroyed(QObject * obj) { callbackQRoomVBoxLayoutWithTriggerSlot_Destroyed(this, obj); };
 +	void disconnectNotify(const QMetaMethod & sign) { callbackQRoomVBoxLayoutWithTriggerSlot_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
 +	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); Moc_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQRoomVBoxLayoutWithTriggerSlot_ObjectNameChanged(this, objectNamePacked); };
 +	void timerEvent(QTimerEvent * event) { callbackQRoomVBoxLayoutWithTriggerSlot_TimerEvent(this, event); };
 +	
 +	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQRoomVBoxLayoutWithTriggerSlot_SpacerItem(this)); };
 +	QWidget * widget() { return static_cast<QWidget*>(callbackQRoomVBoxLayoutWithTriggerSlot_Widget(this)); };
 +signals:
 +	void TriggerRoom(QString roomID);
 +	void ChangeRoom(QString roomID);
 +public slots:
 +private:
 +};
 +
 +Q_DECLARE_METATYPE(QRoomVBoxLayoutWithTriggerSlot*)
 +
 +
 +void QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaTypes() {
 +}
 +
 +class QVBoxLayoutWithTriggerSlot: public QVBoxLayout
 +{
 +Q_OBJECT
 +public:
 +	QVBoxLayoutWithTriggerSlot() : QVBoxLayout() {qRegisterMetaType<quintptr>("quintptr");QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType();QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaTypes();callbackQVBoxLayoutWithTriggerSlot_Constructor(this);};
 +	QVBoxLayoutWithTriggerSlot(QWidget *parent) : QVBoxLayout(parent) {qRegisterMetaType<quintptr>("quintptr");QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType();QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaTypes();callbackQVBoxLayoutWithTriggerSlot_Constructor(this);};
 +	void Signal_TriggerMessage(QString messageBody, QString sender, qint64 timestamp) { QByteArray t59bf16 = messageBody.toUtf8(); Moc_PackedString messageBodyPacked = { const_cast<char*>(t59bf16.prepend("WHITESPACE").constData()+10), t59bf16.size()-10 };QByteArray tacc6a3 = sender.toUtf8(); Moc_PackedString senderPacked = { const_cast<char*>(tacc6a3.prepend("WHITESPACE").constData()+10), tacc6a3.size()-10 };callbackQVBoxLayoutWithTriggerSlot_TriggerMessage(this, messageBodyPacked, senderPacked, timestamp); };
 +	QLayoutItem * takeAt(int index) { return static_cast<QLayoutItem*>(callbackQVBoxLayoutWithTriggerSlot_TakeAt(this, index)); };
 +	void addItem(QLayoutItem * item) { callbackQVBoxLayoutWithTriggerSlot_AddItem(this, item); };
 +	void invalidate() { callbackQVBoxLayoutWithTriggerSlot_Invalidate(this); };
 +	void setGeometry(const QRect & r) { callbackQVBoxLayoutWithTriggerSlot_SetGeometry(this, const_cast<QRect*>(&r)); };
 +	QLayoutItem * itemAt(int index) const { return static_cast<QLayoutItem*>(callbackQVBoxLayoutWithTriggerSlot_ItemAt(const_cast<void*>(static_cast<const void*>(this)), index)); };
 +	QSize maximumSize() const { return *static_cast<QSize*>(callbackQVBoxLayoutWithTriggerSlot_MaximumSize(const_cast<void*>(static_cast<const void*>(this)))); };
 +	QSize minimumSize() const { return *static_cast<QSize*>(callbackQVBoxLayoutWithTriggerSlot_MinimumSize(const_cast<void*>(static_cast<const void*>(this)))); };
 +	QSize sizeHint() const { return *static_cast<QSize*>(callbackQVBoxLayoutWithTriggerSlot_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
 +	Qt::Orientations expandingDirections() const { return static_cast<Qt::Orientation>(callbackQVBoxLayoutWithTriggerSlot_ExpandingDirections(const_cast<void*>(static_cast<const void*>(this)))); };
 +	bool hasHeightForWidth() const { return callbackQVBoxLayoutWithTriggerSlot_HasHeightForWidth(const_cast<void*>(static_cast<const void*>(this))) != 0; };
 +	int count() const { return callbackQVBoxLayoutWithTriggerSlot_Count(const_cast<void*>(static_cast<const void*>(this))); };
 +	int heightForWidth(int w) const { return callbackQVBoxLayoutWithTriggerSlot_HeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
 +	int minimumHeightForWidth(int w) const { return callbackQVBoxLayoutWithTriggerSlot_MinimumHeightForWidth(const_cast<void*>(static_cast<const void*>(this)), w); };
 +	QLayout * layout() { return static_cast<QLayout*>(callbackQVBoxLayoutWithTriggerSlot_Layout(this)); };
 +	void childEvent(QChildEvent * e) { callbackQVBoxLayoutWithTriggerSlot_ChildEvent(this, e); };
 +	QRect geometry() const { return *static_cast<QRect*>(callbackQVBoxLayoutWithTriggerSlot_Geometry(const_cast<void*>(static_cast<const void*>(this)))); };
 +	QSizePolicy::ControlTypes controlTypes() const { return static_cast<QSizePolicy::ControlType>(callbackQVBoxLayoutWithTriggerSlot_ControlTypes(const_cast<void*>(static_cast<const void*>(this)))); };
 +	bool isEmpty() const { return callbackQVBoxLayoutWithTriggerSlot_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
 +	int indexOf(QWidget * widget) const { return callbackQVBoxLayoutWithTriggerSlot_IndexOf(const_cast<void*>(static_cast<const void*>(this)), widget); };
 +	bool event(QEvent * e) { return callbackQVBoxLayoutWithTriggerSlot_Event(this, e) != 0; };
 +	bool eventFilter(QObject * watched, QEvent * event) { return callbackQVBoxLayoutWithTriggerSlot_EventFilter(this, watched, event) != 0; };
 +	void connectNotify(const QMetaMethod & sign) { callbackQVBoxLayoutWithTriggerSlot_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
 +	void customEvent(QEvent * event) { callbackQVBoxLayoutWithTriggerSlot_CustomEvent(this, event); };
 +	void deleteLater() { callbackQVBoxLayoutWithTriggerSlot_DeleteLater(this); };
 +	void Signal_Destroyed(QObject * obj) { callbackQVBoxLayoutWithTriggerSlot_Destroyed(this, obj); };
 +	void disconnectNotify(const QMetaMethod & sign) { callbackQVBoxLayoutWithTriggerSlot_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
 +	void Signal_ObjectNameChanged(const QString & objectName) { QByteArray taa2c4f = objectName.toUtf8(); Moc_PackedString objectNamePacked = { const_cast<char*>(taa2c4f.prepend("WHITESPACE").constData()+10), taa2c4f.size()-10 };callbackQVBoxLayoutWithTriggerSlot_ObjectNameChanged(this, objectNamePacked); };
 +	void timerEvent(QTimerEvent * event) { callbackQVBoxLayoutWithTriggerSlot_TimerEvent(this, event); };
 +	
 +	QSpacerItem * spacerItem() { return static_cast<QSpacerItem*>(callbackQVBoxLayoutWithTriggerSlot_SpacerItem(this)); };
 +	QWidget * widget() { return static_cast<QWidget*>(callbackQVBoxLayoutWithTriggerSlot_Widget(this)); };
 +signals:
 +	void TriggerMessage(QString messageBody, QString sender, qint64 timestamp);
 +public slots:
 +private:
 +};
 +
 +Q_DECLARE_METATYPE(QVBoxLayoutWithTriggerSlot*)
 +
 +
 +void QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaTypes() {
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_ConnectTriggerRoom(void* ptr)
 +{
 +	QObject::connect(static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QRoomVBoxLayoutWithTriggerSlot::*)(QString)>(&QRoomVBoxLayoutWithTriggerSlot::TriggerRoom), static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QRoomVBoxLayoutWithTriggerSlot::*)(QString)>(&QRoomVBoxLayoutWithTriggerSlot::Signal_TriggerRoom));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_DisconnectTriggerRoom(void* ptr)
 +{
 +	QObject::disconnect(static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QRoomVBoxLayoutWithTriggerSlot::*)(QString)>(&QRoomVBoxLayoutWithTriggerSlot::TriggerRoom), static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QRoomVBoxLayoutWithTriggerSlot::*)(QString)>(&QRoomVBoxLayoutWithTriggerSlot::Signal_TriggerRoom));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_TriggerRoom(void* ptr, struct Moc_PackedString roomID)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->TriggerRoom(QString::fromUtf8(roomID.data, roomID.len));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_ConnectChangeRoom(void* ptr)
 +{
 +	QObject::connect(static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QRoomVBoxLayoutWithTriggerSlot::*)(QString)>(&QRoomVBoxLayoutWithTriggerSlot::ChangeRoom), static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QRoomVBoxLayoutWithTriggerSlot::*)(QString)>(&QRoomVBoxLayoutWithTriggerSlot::Signal_ChangeRoom));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_DisconnectChangeRoom(void* ptr)
 +{
 +	QObject::disconnect(static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QRoomVBoxLayoutWithTriggerSlot::*)(QString)>(&QRoomVBoxLayoutWithTriggerSlot::ChangeRoom), static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QRoomVBoxLayoutWithTriggerSlot::*)(QString)>(&QRoomVBoxLayoutWithTriggerSlot::Signal_ChangeRoom));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_ChangeRoom(void* ptr, struct Moc_PackedString roomID)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->ChangeRoom(QString::fromUtf8(roomID.data, roomID.len));
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()
 +{
 +	return qRegisterMetaType<QRoomVBoxLayoutWithTriggerSlot*>();
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(char* typeName)
 +{
 +	return qRegisterMetaType<QRoomVBoxLayoutWithTriggerSlot*>(const_cast<const char*>(typeName));
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()
 +{
 +#ifdef QT_QML_LIB
 +	return qmlRegisterType<QRoomVBoxLayoutWithTriggerSlot>();
 +#else
 +	return 0;
 +#endif
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(char* uri, int versionMajor, int versionMinor, char* qmlName)
 +{
 +#ifdef QT_QML_LIB
 +	return qmlRegisterType<QRoomVBoxLayoutWithTriggerSlot>(const_cast<const char*>(uri), versionMajor, versionMinor, const_cast<const char*>(qmlName));
 +#else
 +	return 0;
 +#endif
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(void* ptr, int i)
 +{
 +	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(void* ptr, void* i)
 +{
 +	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QByteArray>;
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList2(void* ptr, int i)
 +{
 +	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList2(void* ptr, void* i)
 +{
 +	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList2(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QObject*>;
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList3(void* ptr, int i)
 +{
 +	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList3(void* ptr, void* i)
 +{
 +	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList3(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QObject*>;
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList(void* ptr, int i)
 +{
 +	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList(void* ptr, void* i)
 +{
 +	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QObject*>;
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___children_atList(void* ptr, int i)
 +{
 +	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot___children_setList(void* ptr, void* i)
 +{
 +	static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot___children_newList(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QObject *>;
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot()
 +{
 +	return new QRoomVBoxLayoutWithTriggerSlot();
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot2(void* parent)
 +{
 +		return new QRoomVBoxLayoutWithTriggerSlot(static_cast<QWidget*>(parent));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_DestroyQRoomVBoxLayoutWithTriggerSlot(void* ptr)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->~QRoomVBoxLayoutWithTriggerSlot();
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_TakeAtDefault(void* ptr, int index)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::takeAt(index);
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_AddItemDefault(void* ptr, void* item)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::addItem(static_cast<QLayoutItem*>(item));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_InvalidateDefault(void* ptr)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::invalidate();
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_SetGeometryDefault(void* ptr, void* r)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::setGeometry(*static_cast<QRect*>(r));
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_ItemAtDefault(void* ptr, int index)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::itemAt(index);
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_MaximumSizeDefault(void* ptr)
 +{
 +	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_MinimumSizeDefault(void* ptr)
 +{
 +	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_SizeHintDefault(void* ptr)
 +{
 +	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
 +}
 +
 +long long QRoomVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(void* ptr)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::expandingDirections();
 +}
 +
 +char QRoomVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(void* ptr)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::hasHeightForWidth();
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot_CountDefault(void* ptr)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::count();
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot_HeightForWidthDefault(void* ptr, int w)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::heightForWidth(w);
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(void* ptr, int w)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumHeightForWidth(w);
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_LayoutDefault(void* ptr)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::layout();
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_ChildEventDefault(void* ptr, void* e)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::childEvent(static_cast<QChildEvent*>(e));
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_GeometryDefault(void* ptr)
 +{
 +	return ({ QRect tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
 +}
 +
 +long long QRoomVBoxLayoutWithTriggerSlot_ControlTypesDefault(void* ptr)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::controlTypes();
 +}
 +
 +char QRoomVBoxLayoutWithTriggerSlot_IsEmptyDefault(void* ptr)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::isEmpty();
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot_IndexOfDefault(void* ptr, void* widget)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::indexOf(static_cast<QWidget*>(widget));
 +}
 +
 +char QRoomVBoxLayoutWithTriggerSlot_EventDefault(void* ptr, void* e)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
 +}
 +
 +char QRoomVBoxLayoutWithTriggerSlot_EventFilterDefault(void* ptr, void* watched, void* event)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(void* ptr, void* sign)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_CustomEventDefault(void* ptr, void* event)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::customEvent(static_cast<QEvent*>(event));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_DeleteLaterDefault(void* ptr)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::deleteLater();
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(void* ptr, void* sign)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
 +}
 +
 +void QRoomVBoxLayoutWithTriggerSlot_TimerEventDefault(void* ptr, void* event)
 +{
 +	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
 +}
 +
 +
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_SpacerItemDefault(void* ptr)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::spacerItem();
 +}
 +
 +void* QRoomVBoxLayoutWithTriggerSlot_WidgetDefault(void* ptr)
 +{
 +	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::widget();
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_ConnectTriggerMessage(void* ptr)
 +{
 +	QObject::connect(static_cast<QVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QVBoxLayoutWithTriggerSlot::*)(QString, QString, qint64)>(&QVBoxLayoutWithTriggerSlot::TriggerMessage), static_cast<QVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QVBoxLayoutWithTriggerSlot::*)(QString, QString, qint64)>(&QVBoxLayoutWithTriggerSlot::Signal_TriggerMessage));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_DisconnectTriggerMessage(void* ptr)
 +{
 +	QObject::disconnect(static_cast<QVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QVBoxLayoutWithTriggerSlot::*)(QString, QString, qint64)>(&QVBoxLayoutWithTriggerSlot::TriggerMessage), static_cast<QVBoxLayoutWithTriggerSlot*>(ptr), static_cast<void (QVBoxLayoutWithTriggerSlot::*)(QString, QString, qint64)>(&QVBoxLayoutWithTriggerSlot::Signal_TriggerMessage));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_TriggerMessage(void* ptr, struct Moc_PackedString messageBody, struct Moc_PackedString sender, long long timestamp)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->TriggerMessage(QString::fromUtf8(messageBody.data, messageBody.len), QString::fromUtf8(sender.data, sender.len), timestamp);
 +}
 +
 +int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()
 +{
 +	return qRegisterMetaType<QVBoxLayoutWithTriggerSlot*>();
 +}
 +
 +int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(char* typeName)
 +{
 +	return qRegisterMetaType<QVBoxLayoutWithTriggerSlot*>(const_cast<const char*>(typeName));
 +}
 +
 +int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()
 +{
 +#ifdef QT_QML_LIB
 +	return qmlRegisterType<QVBoxLayoutWithTriggerSlot>();
 +#else
 +	return 0;
 +#endif
 +}
 +
 +int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType2(char* uri, int versionMajor, int versionMinor, char* qmlName)
 +{
 +#ifdef QT_QML_LIB
 +	return qmlRegisterType<QVBoxLayoutWithTriggerSlot>(const_cast<const char*>(uri), versionMajor, versionMinor, const_cast<const char*>(qmlName));
 +#else
 +	return 0;
 +#endif
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(void* ptr, int i)
 +{
 +	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(void* ptr, void* i)
 +{
 +	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QByteArray>;
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___findChildren_atList2(void* ptr, int i)
 +{
 +	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot___findChildren_setList2(void* ptr, void* i)
 +{
 +	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___findChildren_newList2(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QObject*>;
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___findChildren_atList3(void* ptr, int i)
 +{
 +	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot___findChildren_setList3(void* ptr, void* i)
 +{
 +	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___findChildren_newList3(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QObject*>;
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___findChildren_atList(void* ptr, int i)
 +{
 +	return const_cast<QObject*>(static_cast<QList<QObject*>*>(ptr)->at(i));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot___findChildren_setList(void* ptr, void* i)
 +{
 +	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___findChildren_newList(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QObject*>;
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___children_atList(void* ptr, int i)
 +{
 +	return const_cast<QObject*>(static_cast<QList<QObject *>*>(ptr)->at(i));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot___children_setList(void* ptr, void* i)
 +{
 +	static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot___children_newList(void* ptr)
 +{
 +	Q_UNUSED(ptr);
 +	return new QList<QObject *>;
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot()
 +{
 +	return new QVBoxLayoutWithTriggerSlot();
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot2(void* parent)
 +{
 +		return new QVBoxLayoutWithTriggerSlot(static_cast<QWidget*>(parent));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_DestroyQVBoxLayoutWithTriggerSlot(void* ptr)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->~QVBoxLayoutWithTriggerSlot();
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_TakeAtDefault(void* ptr, int index)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::takeAt(index);
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_AddItemDefault(void* ptr, void* item)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::addItem(static_cast<QLayoutItem*>(item));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_InvalidateDefault(void* ptr)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::invalidate();
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_SetGeometryDefault(void* ptr, void* r)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::setGeometry(*static_cast<QRect*>(r));
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_ItemAtDefault(void* ptr, int index)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::itemAt(index);
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_MaximumSizeDefault(void* ptr)
 +{
 +	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_MinimumSizeDefault(void* ptr)
 +{
 +	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_SizeHintDefault(void* ptr)
 +{
 +	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
 +}
 +
 +long long QVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(void* ptr)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::expandingDirections();
 +}
 +
 +char QVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(void* ptr)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::hasHeightForWidth();
 +}
 +
 +int QVBoxLayoutWithTriggerSlot_CountDefault(void* ptr)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::count();
 +}
 +
 +int QVBoxLayoutWithTriggerSlot_HeightForWidthDefault(void* ptr, int w)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::heightForWidth(w);
 +}
 +
 +int QVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(void* ptr, int w)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumHeightForWidth(w);
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_LayoutDefault(void* ptr)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::layout();
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_ChildEventDefault(void* ptr, void* e)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::childEvent(static_cast<QChildEvent*>(e));
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_GeometryDefault(void* ptr)
 +{
 +	return ({ QRect tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
 +}
 +
 +long long QVBoxLayoutWithTriggerSlot_ControlTypesDefault(void* ptr)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::controlTypes();
 +}
 +
 +char QVBoxLayoutWithTriggerSlot_IsEmptyDefault(void* ptr)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::isEmpty();
 +}
 +
 +int QVBoxLayoutWithTriggerSlot_IndexOfDefault(void* ptr, void* widget)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::indexOf(static_cast<QWidget*>(widget));
 +}
 +
 +char QVBoxLayoutWithTriggerSlot_EventDefault(void* ptr, void* e)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
 +}
 +
 +char QVBoxLayoutWithTriggerSlot_EventFilterDefault(void* ptr, void* watched, void* event)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(void* ptr, void* sign)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_CustomEventDefault(void* ptr, void* event)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::customEvent(static_cast<QEvent*>(event));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_DeleteLaterDefault(void* ptr)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::deleteLater();
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(void* ptr, void* sign)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
 +}
 +
 +void QVBoxLayoutWithTriggerSlot_TimerEventDefault(void* ptr, void* event)
 +{
 +	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
 +}
 +
 +
 +
 +void* QVBoxLayoutWithTriggerSlot_SpacerItemDefault(void* ptr)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::spacerItem();
 +}
 +
 +void* QVBoxLayoutWithTriggerSlot_WidgetDefault(void* ptr)
 +{
 +	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::widget();
 +}
 +
 +#include "moc_moc.h"
 diff --git a/ui/listLayouts/moc.go b/ui/listLayouts/moc.go
 new file mode 100644
 index 0000000..55fc930
 --- /dev/null
 +++ b/ui/listLayouts/moc.go
 @@ -0,0 +1,1595 @@
 +package listLayouts
 +
 +//#include <stdint.h>
 +//#include <stdlib.h>
 +//#include <string.h>
 +//#include "moc.h"
 +import "C"
 +import (
 +	"runtime"
 +	"unsafe"
 +
 +	"github.com/therecipe/qt"
 +	std_core "github.com/therecipe/qt/core"
 +	std_widgets "github.com/therecipe/qt/widgets"
 +)
 +
 +func cGoUnpackString(s C.struct_Moc_PackedString) string {
 +	if len := int(s.len); len == -1 {
 +		return C.GoString(s.data)
 +	}
 +	return C.GoStringN(s.data, C.int(s.len))
 +}
 +
 +type QRoomVBoxLayoutWithTriggerSlot_ITF interface {
 +	std_widgets.QVBoxLayout_ITF
 +	QRoomVBoxLayoutWithTriggerSlot_PTR() *QRoomVBoxLayoutWithTriggerSlot
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) QRoomVBoxLayoutWithTriggerSlot_PTR() *QRoomVBoxLayoutWithTriggerSlot {
 +	return ptr
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) Pointer() unsafe.Pointer {
 +	if ptr != nil {
 +		return ptr.QVBoxLayout_PTR().Pointer()
 +	}
 +	return nil
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) SetPointer(p unsafe.Pointer) {
 +	if ptr != nil {
 +		ptr.QVBoxLayout_PTR().SetPointer(p)
 +	}
 +}
 +
 +func PointerFromQRoomVBoxLayoutWithTriggerSlot(ptr QRoomVBoxLayoutWithTriggerSlot_ITF) unsafe.Pointer {
 +	if ptr != nil {
 +		return ptr.QRoomVBoxLayoutWithTriggerSlot_PTR().Pointer()
 +	}
 +	return nil
 +}
 +
 +func NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr unsafe.Pointer) *QRoomVBoxLayoutWithTriggerSlot {
 +	var n *QRoomVBoxLayoutWithTriggerSlot
 +	if gPtr, ok := qt.Receive(ptr); !ok {
 +		n = new(QRoomVBoxLayoutWithTriggerSlot)
 +		n.SetPointer(ptr)
 +	} else {
 +		switch deduced := gPtr.(type) {
 +		case *QRoomVBoxLayoutWithTriggerSlot:
 +			n = deduced
 +
 +		case *std_widgets.QVBoxLayout:
 +			n = &QRoomVBoxLayoutWithTriggerSlot{QVBoxLayout: *deduced}
 +
 +		default:
 +			n = new(QRoomVBoxLayoutWithTriggerSlot)
 +			n.SetPointer(ptr)
 +		}
 +	}
 +	return n
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_Constructor
 +func callbackQRoomVBoxLayoutWithTriggerSlot_Constructor(ptr unsafe.Pointer) {
 +	gPtr := NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr)
 +	qt.Register(ptr, gPtr)
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_TriggerRoom
 +func callbackQRoomVBoxLayoutWithTriggerSlot_TriggerRoom(ptr unsafe.Pointer, roomID C.struct_Moc_PackedString) {
 +	if signal := qt.GetSignal(ptr, "TriggerRoom"); signal != nil {
 +		signal.(func(string))(cGoUnpackString(roomID))
 +	}
 +
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) ConnectTriggerRoom(f func(roomID string)) {
 +	if ptr.Pointer() != nil {
 +
 +		if !qt.ExistsSignal(ptr.Pointer(), "TriggerRoom") {
 +			C.QRoomVBoxLayoutWithTriggerSlot_ConnectTriggerRoom(ptr.Pointer())
 +		}
 +
 +		if signal := qt.LendSignal(ptr.Pointer(), "TriggerRoom"); signal != nil {
 +			qt.ConnectSignal(ptr.Pointer(), "TriggerRoom", func(roomID string) {
 +				signal.(func(string))(roomID)
 +				f(roomID)
 +			})
 +		} else {
 +			qt.ConnectSignal(ptr.Pointer(), "TriggerRoom", f)
 +		}
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) DisconnectTriggerRoom() {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_DisconnectTriggerRoom(ptr.Pointer())
 +		qt.DisconnectSignal(ptr.Pointer(), "TriggerRoom")
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) TriggerRoom(roomID string) {
 +	if ptr.Pointer() != nil {
 +		var roomIDC *C.char
 +		if roomID != "" {
 +			roomIDC = C.CString(roomID)
 +			defer C.free(unsafe.Pointer(roomIDC))
 +		}
 +		C.QRoomVBoxLayoutWithTriggerSlot_TriggerRoom(ptr.Pointer(), C.struct_Moc_PackedString{data: roomIDC, len: C.longlong(len(roomID))})
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_ChangeRoom
 +func callbackQRoomVBoxLayoutWithTriggerSlot_ChangeRoom(ptr unsafe.Pointer, roomID C.struct_Moc_PackedString) {
 +	if signal := qt.GetSignal(ptr, "ChangeRoom"); signal != nil {
 +		signal.(func(string))(cGoUnpackString(roomID))
 +	}
 +
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) ConnectChangeRoom(f func(roomID string)) {
 +	if ptr.Pointer() != nil {
 +
 +		if !qt.ExistsSignal(ptr.Pointer(), "ChangeRoom") {
 +			C.QRoomVBoxLayoutWithTriggerSlot_ConnectChangeRoom(ptr.Pointer())
 +		}
 +
 +		if signal := qt.LendSignal(ptr.Pointer(), "ChangeRoom"); signal != nil {
 +			qt.ConnectSignal(ptr.Pointer(), "ChangeRoom", func(roomID string) {
 +				signal.(func(string))(roomID)
 +				f(roomID)
 +			})
 +		} else {
 +			qt.ConnectSignal(ptr.Pointer(), "ChangeRoom", f)
 +		}
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) DisconnectChangeRoom() {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_DisconnectChangeRoom(ptr.Pointer())
 +		qt.DisconnectSignal(ptr.Pointer(), "ChangeRoom")
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) ChangeRoom(roomID string) {
 +	if ptr.Pointer() != nil {
 +		var roomIDC *C.char
 +		if roomID != "" {
 +			roomIDC = C.CString(roomID)
 +			defer C.free(unsafe.Pointer(roomIDC))
 +		}
 +		C.QRoomVBoxLayoutWithTriggerSlot_ChangeRoom(ptr.Pointer(), C.struct_Moc_PackedString{data: roomIDC, len: C.longlong(len(roomID))})
 +	}
 +}
 +
 +func QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType() int {
 +	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) QRegisterMetaType() int {
 +	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
 +}
 +
 +func QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeName string) int {
 +	var typeNameC *C.char
 +	if typeName != "" {
 +		typeNameC = C.CString(typeName)
 +		defer C.free(unsafe.Pointer(typeNameC))
 +	}
 +	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) QRegisterMetaType2(typeName string) int {
 +	var typeNameC *C.char
 +	if typeName != "" {
 +		typeNameC = C.CString(typeName)
 +		defer C.free(unsafe.Pointer(typeNameC))
 +	}
 +	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
 +}
 +
 +func QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType() int {
 +	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) QmlRegisterType() int {
 +	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()))
 +}
 +
 +func QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
 +	var uriC *C.char
 +	if uri != "" {
 +		uriC = C.CString(uri)
 +		defer C.free(unsafe.Pointer(uriC))
 +	}
 +	var qmlNameC *C.char
 +	if qmlName != "" {
 +		qmlNameC = C.CString(qmlName)
 +		defer C.free(unsafe.Pointer(qmlNameC))
 +	}
 +	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
 +	var uriC *C.char
 +	if uri != "" {
 +		uriC = C.CString(uri)
 +		defer C.free(unsafe.Pointer(uriC))
 +	}
 +	var qmlNameC *C.char
 +	if qmlName != "" {
 +		qmlNameC = C.CString(qmlName)
 +		defer C.free(unsafe.Pointer(qmlNameC))
 +	}
 +	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_atList(i int) *std_core.QByteArray {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQByteArrayFromPointer(C.QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QByteArray).DestroyQByteArray)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_setList(i std_core.QByteArray_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(ptr.Pointer(), std_core.PointerFromQByteArray(i))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_newList() unsafe.Pointer {
 +	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(ptr.Pointer()))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList2(i int) *std_core.QObject {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQObjectFromPointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList2(i std_core.QObject_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot___findChildren_setList2(ptr.Pointer(), std_core.PointerFromQObject(i))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_newList2() unsafe.Pointer {
 +	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_newList2(ptr.Pointer()))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList3(i int) *std_core.QObject {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQObjectFromPointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList3(i std_core.QObject_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot___findChildren_setList3(ptr.Pointer(), std_core.PointerFromQObject(i))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_newList3() unsafe.Pointer {
 +	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_newList3(ptr.Pointer()))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList(i int) *std_core.QObject {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQObjectFromPointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList(i std_core.QObject_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot___findChildren_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_newList() unsafe.Pointer {
 +	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_newList(ptr.Pointer()))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __children_atList(i int) *std_core.QObject {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQObjectFromPointer(C.QRoomVBoxLayoutWithTriggerSlot___children_atList(ptr.Pointer(), C.int(int32(i))))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __children_setList(i std_core.QObject_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot___children_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) __children_newList() unsafe.Pointer {
 +	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___children_newList(ptr.Pointer()))
 +}
 +
 +func NewQRoomVBoxLayoutWithTriggerSlot() *QRoomVBoxLayoutWithTriggerSlot {
 +	var tmpValue = NewQRoomVBoxLayoutWithTriggerSlotFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot())
 +	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +		tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +	}
 +	return tmpValue
 +}
 +
 +func NewQRoomVBoxLayoutWithTriggerSlot2(parent std_widgets.QWidget_ITF) *QRoomVBoxLayoutWithTriggerSlot {
 +	var tmpValue = NewQRoomVBoxLayoutWithTriggerSlotFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot2(std_widgets.PointerFromQWidget(parent)))
 +	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +		tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +	}
 +	return tmpValue
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) DestroyQRoomVBoxLayoutWithTriggerSlot() {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_DestroyQRoomVBoxLayoutWithTriggerSlot(ptr.Pointer())
 +		ptr.SetPointer(nil)
 +		runtime.SetFinalizer(ptr, nil)
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_TakeAt
 +func callbackQRoomVBoxLayoutWithTriggerSlot_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "takeAt"); signal != nil {
 +		return std_widgets.PointerFromQLayoutItem(signal.(func(int) *std_widgets.QLayoutItem)(int(int32(index))))
 +	}
 +
 +	return std_widgets.PointerFromQLayoutItem(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).TakeAtDefault(int(int32(index))))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) TakeAtDefault(index int) *std_widgets.QLayoutItem {
 +	if ptr.Pointer() != nil {
 +		return std_widgets.NewQLayoutItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
 +	}
 +	return nil
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_AddItem
 +func callbackQRoomVBoxLayoutWithTriggerSlot_AddItem(ptr unsafe.Pointer, item unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "addItem"); signal != nil {
 +		signal.(func(*std_widgets.QLayoutItem))(std_widgets.NewQLayoutItemFromPointer(item))
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).AddItemDefault(std_widgets.NewQLayoutItemFromPointer(item))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) AddItemDefault(item std_widgets.QLayoutItem_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_AddItemDefault(ptr.Pointer(), std_widgets.PointerFromQLayoutItem(item))
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_Invalidate
 +func callbackQRoomVBoxLayoutWithTriggerSlot_Invalidate(ptr unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "invalidate"); signal != nil {
 +		signal.(func())()
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).InvalidateDefault()
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) InvalidateDefault() {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_InvalidateDefault(ptr.Pointer())
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_SetGeometry
 +func callbackQRoomVBoxLayoutWithTriggerSlot_SetGeometry(ptr unsafe.Pointer, r unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "setGeometry"); signal != nil {
 +		signal.(func(*std_core.QRect))(std_core.NewQRectFromPointer(r))
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SetGeometryDefault(std_core.NewQRectFromPointer(r))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) SetGeometryDefault(r std_core.QRect_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_SetGeometryDefault(ptr.Pointer(), std_core.PointerFromQRect(r))
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_ItemAt
 +func callbackQRoomVBoxLayoutWithTriggerSlot_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
 +		return std_widgets.PointerFromQLayoutItem(signal.(func(int) *std_widgets.QLayoutItem)(int(int32(index))))
 +	}
 +
 +	return std_widgets.PointerFromQLayoutItem(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ItemAtDefault(int(int32(index))))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) ItemAtDefault(index int) *std_widgets.QLayoutItem {
 +	if ptr.Pointer() != nil {
 +		return std_widgets.NewQLayoutItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
 +	}
 +	return nil
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_MaximumSize
 +func callbackQRoomVBoxLayoutWithTriggerSlot_MaximumSize(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "maximumSize"); signal != nil {
 +		return std_core.PointerFromQSize(signal.(func() *std_core.QSize)())
 +	}
 +
 +	return std_core.PointerFromQSize(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MaximumSizeDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) MaximumSizeDefault() *std_core.QSize {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_MaximumSizeDefault(ptr.Pointer()))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_MinimumSize
 +func callbackQRoomVBoxLayoutWithTriggerSlot_MinimumSize(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "minimumSize"); signal != nil {
 +		return std_core.PointerFromQSize(signal.(func() *std_core.QSize)())
 +	}
 +
 +	return std_core.PointerFromQSize(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumSizeDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) MinimumSizeDefault() *std_core.QSize {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_MinimumSizeDefault(ptr.Pointer()))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_SizeHint
 +func callbackQRoomVBoxLayoutWithTriggerSlot_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
 +		return std_core.PointerFromQSize(signal.(func() *std_core.QSize)())
 +	}
 +
 +	return std_core.PointerFromQSize(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SizeHintDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) SizeHintDefault() *std_core.QSize {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_SizeHintDefault(ptr.Pointer()))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_ExpandingDirections
 +func callbackQRoomVBoxLayoutWithTriggerSlot_ExpandingDirections(ptr unsafe.Pointer) C.longlong {
 +	if signal := qt.GetSignal(ptr, "expandingDirections"); signal != nil {
 +		return C.longlong(signal.(func() std_core.Qt__Orientation)())
 +	}
 +
 +	return C.longlong(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ExpandingDirectionsDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) ExpandingDirectionsDefault() std_core.Qt__Orientation {
 +	if ptr.Pointer() != nil {
 +		return std_core.Qt__Orientation(C.QRoomVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(ptr.Pointer()))
 +	}
 +	return 0
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_HasHeightForWidth
 +func callbackQRoomVBoxLayoutWithTriggerSlot_HasHeightForWidth(ptr unsafe.Pointer) C.char {
 +	if signal := qt.GetSignal(ptr, "hasHeightForWidth"); signal != nil {
 +		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
 +	}
 +
 +	return C.char(int8(qt.GoBoolToInt(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).HasHeightForWidthDefault())))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) HasHeightForWidthDefault() bool {
 +	if ptr.Pointer() != nil {
 +		return C.QRoomVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(ptr.Pointer()) != 0
 +	}
 +	return false
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_Count
 +func callbackQRoomVBoxLayoutWithTriggerSlot_Count(ptr unsafe.Pointer) C.int {
 +	if signal := qt.GetSignal(ptr, "count"); signal != nil {
 +		return C.int(int32(signal.(func() int)()))
 +	}
 +
 +	return C.int(int32(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).CountDefault()))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) CountDefault() int {
 +	if ptr.Pointer() != nil {
 +		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_CountDefault(ptr.Pointer())))
 +	}
 +	return 0
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_HeightForWidth
 +func callbackQRoomVBoxLayoutWithTriggerSlot_HeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
 +	if signal := qt.GetSignal(ptr, "heightForWidth"); signal != nil {
 +		return C.int(int32(signal.(func(int) int)(int(int32(w)))))
 +	}
 +
 +	return C.int(int32(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) HeightForWidthDefault(w int) int {
 +	if ptr.Pointer() != nil {
 +		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
 +	}
 +	return 0
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidth
 +func callbackQRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
 +	if signal := qt.GetSignal(ptr, "minimumHeightForWidth"); signal != nil {
 +		return C.int(int32(signal.(func(int) int)(int(int32(w)))))
 +	}
 +
 +	return C.int(int32(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumHeightForWidthDefault(int(int32(w)))))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) MinimumHeightForWidthDefault(w int) int {
 +	if ptr.Pointer() != nil {
 +		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
 +	}
 +	return 0
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_Layout
 +func callbackQRoomVBoxLayoutWithTriggerSlot_Layout(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "layout"); signal != nil {
 +		return std_widgets.PointerFromQLayout(signal.(func() *std_widgets.QLayout)())
 +	}
 +
 +	return std_widgets.PointerFromQLayout(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).LayoutDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) LayoutDefault() *std_widgets.QLayout {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_widgets.NewQLayoutFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_LayoutDefault(ptr.Pointer()))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_ChildEvent
 +func callbackQRoomVBoxLayoutWithTriggerSlot_ChildEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
 +		signal.(func(*std_core.QChildEvent))(std_core.NewQChildEventFromPointer(e))
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ChildEventDefault(std_core.NewQChildEventFromPointer(e))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) ChildEventDefault(e std_core.QChildEvent_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_ChildEventDefault(ptr.Pointer(), std_core.PointerFromQChildEvent(e))
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_Geometry
 +func callbackQRoomVBoxLayoutWithTriggerSlot_Geometry(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "geometry"); signal != nil {
 +		return std_core.PointerFromQRect(signal.(func() *std_core.QRect)())
 +	}
 +
 +	return std_core.PointerFromQRect(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).GeometryDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) GeometryDefault() *std_core.QRect {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQRectFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_GeometryDefault(ptr.Pointer()))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QRect).DestroyQRect)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_ControlTypes
 +func callbackQRoomVBoxLayoutWithTriggerSlot_ControlTypes(ptr unsafe.Pointer) C.longlong {
 +	if signal := qt.GetSignal(ptr, "controlTypes"); signal != nil {
 +		return C.longlong(signal.(func() std_widgets.QSizePolicy__ControlType)())
 +	}
 +
 +	return C.longlong(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ControlTypesDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) ControlTypesDefault() std_widgets.QSizePolicy__ControlType {
 +	if ptr.Pointer() != nil {
 +		return std_widgets.QSizePolicy__ControlType(C.QRoomVBoxLayoutWithTriggerSlot_ControlTypesDefault(ptr.Pointer()))
 +	}
 +	return 0
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_IsEmpty
 +func callbackQRoomVBoxLayoutWithTriggerSlot_IsEmpty(ptr unsafe.Pointer) C.char {
 +	if signal := qt.GetSignal(ptr, "isEmpty"); signal != nil {
 +		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
 +	}
 +
 +	return C.char(int8(qt.GoBoolToInt(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).IsEmptyDefault())))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) IsEmptyDefault() bool {
 +	if ptr.Pointer() != nil {
 +		return C.QRoomVBoxLayoutWithTriggerSlot_IsEmptyDefault(ptr.Pointer()) != 0
 +	}
 +	return false
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_IndexOf
 +func callbackQRoomVBoxLayoutWithTriggerSlot_IndexOf(ptr unsafe.Pointer, widget unsafe.Pointer) C.int {
 +	if signal := qt.GetSignal(ptr, "indexOf"); signal != nil {
 +		return C.int(int32(signal.(func(*std_widgets.QWidget) int)(std_widgets.NewQWidgetFromPointer(widget))))
 +	}
 +
 +	return C.int(int32(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).IndexOfDefault(std_widgets.NewQWidgetFromPointer(widget))))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) IndexOfDefault(widget std_widgets.QWidget_ITF) int {
 +	if ptr.Pointer() != nil {
 +		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_IndexOfDefault(ptr.Pointer(), std_widgets.PointerFromQWidget(widget))))
 +	}
 +	return 0
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_Event
 +func callbackQRoomVBoxLayoutWithTriggerSlot_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
 +	if signal := qt.GetSignal(ptr, "event"); signal != nil {
 +		return C.char(int8(qt.GoBoolToInt(signal.(func(*std_core.QEvent) bool)(std_core.NewQEventFromPointer(e)))))
 +	}
 +
 +	return C.char(int8(qt.GoBoolToInt(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).EventDefault(std_core.NewQEventFromPointer(e)))))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) EventDefault(e std_core.QEvent_ITF) bool {
 +	if ptr.Pointer() != nil {
 +		return C.QRoomVBoxLayoutWithTriggerSlot_EventDefault(ptr.Pointer(), std_core.PointerFromQEvent(e)) != 0
 +	}
 +	return false
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_EventFilter
 +func callbackQRoomVBoxLayoutWithTriggerSlot_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
 +	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
 +		return C.char(int8(qt.GoBoolToInt(signal.(func(*std_core.QObject, *std_core.QEvent) bool)(std_core.NewQObjectFromPointer(watched), std_core.NewQEventFromPointer(event)))))
 +	}
 +
 +	return C.char(int8(qt.GoBoolToInt(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).EventFilterDefault(std_core.NewQObjectFromPointer(watched), std_core.NewQEventFromPointer(event)))))
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) EventFilterDefault(watched std_core.QObject_ITF, event std_core.QEvent_ITF) bool {
 +	if ptr.Pointer() != nil {
 +		return C.QRoomVBoxLayoutWithTriggerSlot_EventFilterDefault(ptr.Pointer(), std_core.PointerFromQObject(watched), std_core.PointerFromQEvent(event)) != 0
 +	}
 +	return false
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_ConnectNotify
 +func callbackQRoomVBoxLayoutWithTriggerSlot_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
 +		signal.(func(*std_core.QMetaMethod))(std_core.NewQMetaMethodFromPointer(sign))
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ConnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) ConnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_CustomEvent
 +func callbackQRoomVBoxLayoutWithTriggerSlot_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
 +		signal.(func(*std_core.QEvent))(std_core.NewQEventFromPointer(event))
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).CustomEventDefault(std_core.NewQEventFromPointer(event))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) CustomEventDefault(event std_core.QEvent_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_CustomEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_DeleteLater
 +func callbackQRoomVBoxLayoutWithTriggerSlot_DeleteLater(ptr unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
 +		signal.(func())()
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).DeleteLaterDefault()
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) DeleteLaterDefault() {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_DeleteLaterDefault(ptr.Pointer())
 +		ptr.SetPointer(nil)
 +		runtime.SetFinalizer(ptr, nil)
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_Destroyed
 +func callbackQRoomVBoxLayoutWithTriggerSlot_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
 +		signal.(func(*std_core.QObject))(std_core.NewQObjectFromPointer(obj))
 +	}
 +
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_DisconnectNotify
 +func callbackQRoomVBoxLayoutWithTriggerSlot_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
 +		signal.(func(*std_core.QMetaMethod))(std_core.NewQMetaMethodFromPointer(sign))
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).DisconnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) DisconnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_ObjectNameChanged
 +func callbackQRoomVBoxLayoutWithTriggerSlot_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_Moc_PackedString) {
 +	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
 +		signal.(func(string))(cGoUnpackString(objectName))
 +	}
 +
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_TimerEvent
 +func callbackQRoomVBoxLayoutWithTriggerSlot_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
 +		signal.(func(*std_core.QTimerEvent))(std_core.NewQTimerEventFromPointer(event))
 +	} else {
 +		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).TimerEventDefault(std_core.NewQTimerEventFromPointer(event))
 +	}
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) TimerEventDefault(event std_core.QTimerEvent_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QRoomVBoxLayoutWithTriggerSlot_TimerEventDefault(ptr.Pointer(), std_core.PointerFromQTimerEvent(event))
 +	}
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_SpacerItem
 +func callbackQRoomVBoxLayoutWithTriggerSlot_SpacerItem(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "spacerItem"); signal != nil {
 +		return std_widgets.PointerFromQSpacerItem(signal.(func() *std_widgets.QSpacerItem)())
 +	}
 +
 +	return std_widgets.PointerFromQSpacerItem(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SpacerItemDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) SpacerItemDefault() *std_widgets.QSpacerItem {
 +	if ptr.Pointer() != nil {
 +		return std_widgets.NewQSpacerItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_SpacerItemDefault(ptr.Pointer()))
 +	}
 +	return nil
 +}
 +
 +//export callbackQRoomVBoxLayoutWithTriggerSlot_Widget
 +func callbackQRoomVBoxLayoutWithTriggerSlot_Widget(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "widget"); signal != nil {
 +		return std_widgets.PointerFromQWidget(signal.(func() *std_widgets.QWidget)())
 +	}
 +
 +	return std_widgets.PointerFromQWidget(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).WidgetDefault())
 +}
 +
 +func (ptr *QRoomVBoxLayoutWithTriggerSlot) WidgetDefault() *std_widgets.QWidget {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_widgets.NewQWidgetFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_WidgetDefault(ptr.Pointer()))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +type QVBoxLayoutWithTriggerSlot_ITF interface {
 +	std_widgets.QVBoxLayout_ITF
 +	QVBoxLayoutWithTriggerSlot_PTR() *QVBoxLayoutWithTriggerSlot
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) QVBoxLayoutWithTriggerSlot_PTR() *QVBoxLayoutWithTriggerSlot {
 +	return ptr
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) Pointer() unsafe.Pointer {
 +	if ptr != nil {
 +		return ptr.QVBoxLayout_PTR().Pointer()
 +	}
 +	return nil
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) SetPointer(p unsafe.Pointer) {
 +	if ptr != nil {
 +		ptr.QVBoxLayout_PTR().SetPointer(p)
 +	}
 +}
 +
 +func PointerFromQVBoxLayoutWithTriggerSlot(ptr QVBoxLayoutWithTriggerSlot_ITF) unsafe.Pointer {
 +	if ptr != nil {
 +		return ptr.QVBoxLayoutWithTriggerSlot_PTR().Pointer()
 +	}
 +	return nil
 +}
 +
 +func NewQVBoxLayoutWithTriggerSlotFromPointer(ptr unsafe.Pointer) *QVBoxLayoutWithTriggerSlot {
 +	var n *QVBoxLayoutWithTriggerSlot
 +	if gPtr, ok := qt.Receive(ptr); !ok {
 +		n = new(QVBoxLayoutWithTriggerSlot)
 +		n.SetPointer(ptr)
 +	} else {
 +		switch deduced := gPtr.(type) {
 +		case *QVBoxLayoutWithTriggerSlot:
 +			n = deduced
 +
 +		case *std_widgets.QVBoxLayout:
 +			n = &QVBoxLayoutWithTriggerSlot{QVBoxLayout: *deduced}
 +
 +		default:
 +			n = new(QVBoxLayoutWithTriggerSlot)
 +			n.SetPointer(ptr)
 +		}
 +	}
 +	return n
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_Constructor
 +func callbackQVBoxLayoutWithTriggerSlot_Constructor(ptr unsafe.Pointer) {
 +	gPtr := NewQVBoxLayoutWithTriggerSlotFromPointer(ptr)
 +	qt.Register(ptr, gPtr)
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_TriggerMessage
 +func callbackQVBoxLayoutWithTriggerSlot_TriggerMessage(ptr unsafe.Pointer, messageBody C.struct_Moc_PackedString, sender C.struct_Moc_PackedString, timestamp C.longlong) {
 +	if signal := qt.GetSignal(ptr, "TriggerMessage"); signal != nil {
 +		signal.(func(string, string, int64))(cGoUnpackString(messageBody), cGoUnpackString(sender), int64(timestamp))
 +	}
 +
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) ConnectTriggerMessage(f func(messageBody string, sender string, timestamp int64)) {
 +	if ptr.Pointer() != nil {
 +
 +		if !qt.ExistsSignal(ptr.Pointer(), "TriggerMessage") {
 +			C.QVBoxLayoutWithTriggerSlot_ConnectTriggerMessage(ptr.Pointer())
 +		}
 +
 +		if signal := qt.LendSignal(ptr.Pointer(), "TriggerMessage"); signal != nil {
 +			qt.ConnectSignal(ptr.Pointer(), "TriggerMessage", func(messageBody string, sender string, timestamp int64) {
 +				signal.(func(string, string, int64))(messageBody, sender, timestamp)
 +				f(messageBody, sender, timestamp)
 +			})
 +		} else {
 +			qt.ConnectSignal(ptr.Pointer(), "TriggerMessage", f)
 +		}
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) DisconnectTriggerMessage() {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_DisconnectTriggerMessage(ptr.Pointer())
 +		qt.DisconnectSignal(ptr.Pointer(), "TriggerMessage")
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) TriggerMessage(messageBody string, sender string, timestamp int64) {
 +	if ptr.Pointer() != nil {
 +		var messageBodyC *C.char
 +		if messageBody != "" {
 +			messageBodyC = C.CString(messageBody)
 +			defer C.free(unsafe.Pointer(messageBodyC))
 +		}
 +		var senderC *C.char
 +		if sender != "" {
 +			senderC = C.CString(sender)
 +			defer C.free(unsafe.Pointer(senderC))
 +		}
 +		C.QVBoxLayoutWithTriggerSlot_TriggerMessage(ptr.Pointer(), C.struct_Moc_PackedString{data: messageBodyC, len: C.longlong(len(messageBody))}, C.struct_Moc_PackedString{data: senderC, len: C.longlong(len(sender))}, C.longlong(timestamp))
 +	}
 +}
 +
 +func QVBoxLayoutWithTriggerSlot_QRegisterMetaType() int {
 +	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) QRegisterMetaType() int {
 +	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
 +}
 +
 +func QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeName string) int {
 +	var typeNameC *C.char
 +	if typeName != "" {
 +		typeNameC = C.CString(typeName)
 +		defer C.free(unsafe.Pointer(typeNameC))
 +	}
 +	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) QRegisterMetaType2(typeName string) int {
 +	var typeNameC *C.char
 +	if typeName != "" {
 +		typeNameC = C.CString(typeName)
 +		defer C.free(unsafe.Pointer(typeNameC))
 +	}
 +	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
 +}
 +
 +func QVBoxLayoutWithTriggerSlot_QmlRegisterType() int {
 +	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) QmlRegisterType() int {
 +	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()))
 +}
 +
 +func QVBoxLayoutWithTriggerSlot_QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
 +	var uriC *C.char
 +	if uri != "" {
 +		uriC = C.CString(uri)
 +		defer C.free(unsafe.Pointer(uriC))
 +	}
 +	var qmlNameC *C.char
 +	if qmlName != "" {
 +		qmlNameC = C.CString(qmlName)
 +		defer C.free(unsafe.Pointer(qmlNameC))
 +	}
 +	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
 +	var uriC *C.char
 +	if uri != "" {
 +		uriC = C.CString(uri)
 +		defer C.free(unsafe.Pointer(uriC))
 +	}
 +	var qmlNameC *C.char
 +	if qmlName != "" {
 +		qmlNameC = C.CString(qmlName)
 +		defer C.free(unsafe.Pointer(qmlNameC))
 +	}
 +	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_atList(i int) *std_core.QByteArray {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQByteArrayFromPointer(C.QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QByteArray).DestroyQByteArray)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_setList(i std_core.QByteArray_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(ptr.Pointer(), std_core.PointerFromQByteArray(i))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_newList() unsafe.Pointer {
 +	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(ptr.Pointer()))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList2(i int) *std_core.QObject {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQObjectFromPointer(C.QVBoxLayoutWithTriggerSlot___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList2(i std_core.QObject_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot___findChildren_setList2(ptr.Pointer(), std_core.PointerFromQObject(i))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_newList2() unsafe.Pointer {
 +	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___findChildren_newList2(ptr.Pointer()))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList3(i int) *std_core.QObject {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQObjectFromPointer(C.QVBoxLayoutWithTriggerSlot___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList3(i std_core.QObject_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot___findChildren_setList3(ptr.Pointer(), std_core.PointerFromQObject(i))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_newList3() unsafe.Pointer {
 +	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___findChildren_newList3(ptr.Pointer()))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList(i int) *std_core.QObject {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQObjectFromPointer(C.QVBoxLayoutWithTriggerSlot___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList(i std_core.QObject_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot___findChildren_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_newList() unsafe.Pointer {
 +	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___findChildren_newList(ptr.Pointer()))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __children_atList(i int) *std_core.QObject {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQObjectFromPointer(C.QVBoxLayoutWithTriggerSlot___children_atList(ptr.Pointer(), C.int(int32(i))))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __children_setList(i std_core.QObject_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot___children_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) __children_newList() unsafe.Pointer {
 +	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___children_newList(ptr.Pointer()))
 +}
 +
 +func NewQVBoxLayoutWithTriggerSlot() *QVBoxLayoutWithTriggerSlot {
 +	var tmpValue = NewQVBoxLayoutWithTriggerSlotFromPointer(C.QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot())
 +	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +		tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +	}
 +	return tmpValue
 +}
 +
 +func NewQVBoxLayoutWithTriggerSlot2(parent std_widgets.QWidget_ITF) *QVBoxLayoutWithTriggerSlot {
 +	var tmpValue = NewQVBoxLayoutWithTriggerSlotFromPointer(C.QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot2(std_widgets.PointerFromQWidget(parent)))
 +	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +		tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +	}
 +	return tmpValue
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) DestroyQVBoxLayoutWithTriggerSlot() {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_DestroyQVBoxLayoutWithTriggerSlot(ptr.Pointer())
 +		ptr.SetPointer(nil)
 +		runtime.SetFinalizer(ptr, nil)
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_TakeAt
 +func callbackQVBoxLayoutWithTriggerSlot_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "takeAt"); signal != nil {
 +		return std_widgets.PointerFromQLayoutItem(signal.(func(int) *std_widgets.QLayoutItem)(int(int32(index))))
 +	}
 +
 +	return std_widgets.PointerFromQLayoutItem(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).TakeAtDefault(int(int32(index))))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) TakeAtDefault(index int) *std_widgets.QLayoutItem {
 +	if ptr.Pointer() != nil {
 +		return std_widgets.NewQLayoutItemFromPointer(C.QVBoxLayoutWithTriggerSlot_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
 +	}
 +	return nil
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_AddItem
 +func callbackQVBoxLayoutWithTriggerSlot_AddItem(ptr unsafe.Pointer, item unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "addItem"); signal != nil {
 +		signal.(func(*std_widgets.QLayoutItem))(std_widgets.NewQLayoutItemFromPointer(item))
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).AddItemDefault(std_widgets.NewQLayoutItemFromPointer(item))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) AddItemDefault(item std_widgets.QLayoutItem_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_AddItemDefault(ptr.Pointer(), std_widgets.PointerFromQLayoutItem(item))
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_Invalidate
 +func callbackQVBoxLayoutWithTriggerSlot_Invalidate(ptr unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "invalidate"); signal != nil {
 +		signal.(func())()
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).InvalidateDefault()
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) InvalidateDefault() {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_InvalidateDefault(ptr.Pointer())
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_SetGeometry
 +func callbackQVBoxLayoutWithTriggerSlot_SetGeometry(ptr unsafe.Pointer, r unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "setGeometry"); signal != nil {
 +		signal.(func(*std_core.QRect))(std_core.NewQRectFromPointer(r))
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SetGeometryDefault(std_core.NewQRectFromPointer(r))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) SetGeometryDefault(r std_core.QRect_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_SetGeometryDefault(ptr.Pointer(), std_core.PointerFromQRect(r))
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_ItemAt
 +func callbackQVBoxLayoutWithTriggerSlot_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "itemAt"); signal != nil {
 +		return std_widgets.PointerFromQLayoutItem(signal.(func(int) *std_widgets.QLayoutItem)(int(int32(index))))
 +	}
 +
 +	return std_widgets.PointerFromQLayoutItem(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ItemAtDefault(int(int32(index))))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) ItemAtDefault(index int) *std_widgets.QLayoutItem {
 +	if ptr.Pointer() != nil {
 +		return std_widgets.NewQLayoutItemFromPointer(C.QVBoxLayoutWithTriggerSlot_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
 +	}
 +	return nil
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_MaximumSize
 +func callbackQVBoxLayoutWithTriggerSlot_MaximumSize(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "maximumSize"); signal != nil {
 +		return std_core.PointerFromQSize(signal.(func() *std_core.QSize)())
 +	}
 +
 +	return std_core.PointerFromQSize(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MaximumSizeDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) MaximumSizeDefault() *std_core.QSize {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_MaximumSizeDefault(ptr.Pointer()))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_MinimumSize
 +func callbackQVBoxLayoutWithTriggerSlot_MinimumSize(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "minimumSize"); signal != nil {
 +		return std_core.PointerFromQSize(signal.(func() *std_core.QSize)())
 +	}
 +
 +	return std_core.PointerFromQSize(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumSizeDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) MinimumSizeDefault() *std_core.QSize {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_MinimumSizeDefault(ptr.Pointer()))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_SizeHint
 +func callbackQVBoxLayoutWithTriggerSlot_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
 +		return std_core.PointerFromQSize(signal.(func() *std_core.QSize)())
 +	}
 +
 +	return std_core.PointerFromQSize(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SizeHintDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) SizeHintDefault() *std_core.QSize {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_SizeHintDefault(ptr.Pointer()))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_ExpandingDirections
 +func callbackQVBoxLayoutWithTriggerSlot_ExpandingDirections(ptr unsafe.Pointer) C.longlong {
 +	if signal := qt.GetSignal(ptr, "expandingDirections"); signal != nil {
 +		return C.longlong(signal.(func() std_core.Qt__Orientation)())
 +	}
 +
 +	return C.longlong(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ExpandingDirectionsDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) ExpandingDirectionsDefault() std_core.Qt__Orientation {
 +	if ptr.Pointer() != nil {
 +		return std_core.Qt__Orientation(C.QVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(ptr.Pointer()))
 +	}
 +	return 0
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_HasHeightForWidth
 +func callbackQVBoxLayoutWithTriggerSlot_HasHeightForWidth(ptr unsafe.Pointer) C.char {
 +	if signal := qt.GetSignal(ptr, "hasHeightForWidth"); signal != nil {
 +		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
 +	}
 +
 +	return C.char(int8(qt.GoBoolToInt(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).HasHeightForWidthDefault())))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) HasHeightForWidthDefault() bool {
 +	if ptr.Pointer() != nil {
 +		return C.QVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(ptr.Pointer()) != 0
 +	}
 +	return false
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_Count
 +func callbackQVBoxLayoutWithTriggerSlot_Count(ptr unsafe.Pointer) C.int {
 +	if signal := qt.GetSignal(ptr, "count"); signal != nil {
 +		return C.int(int32(signal.(func() int)()))
 +	}
 +
 +	return C.int(int32(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).CountDefault()))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) CountDefault() int {
 +	if ptr.Pointer() != nil {
 +		return int(int32(C.QVBoxLayoutWithTriggerSlot_CountDefault(ptr.Pointer())))
 +	}
 +	return 0
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_HeightForWidth
 +func callbackQVBoxLayoutWithTriggerSlot_HeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
 +	if signal := qt.GetSignal(ptr, "heightForWidth"); signal != nil {
 +		return C.int(int32(signal.(func(int) int)(int(int32(w)))))
 +	}
 +
 +	return C.int(int32(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) HeightForWidthDefault(w int) int {
 +	if ptr.Pointer() != nil {
 +		return int(int32(C.QVBoxLayoutWithTriggerSlot_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
 +	}
 +	return 0
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_MinimumHeightForWidth
 +func callbackQVBoxLayoutWithTriggerSlot_MinimumHeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
 +	if signal := qt.GetSignal(ptr, "minimumHeightForWidth"); signal != nil {
 +		return C.int(int32(signal.(func(int) int)(int(int32(w)))))
 +	}
 +
 +	return C.int(int32(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumHeightForWidthDefault(int(int32(w)))))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) MinimumHeightForWidthDefault(w int) int {
 +	if ptr.Pointer() != nil {
 +		return int(int32(C.QVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
 +	}
 +	return 0
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_Layout
 +func callbackQVBoxLayoutWithTriggerSlot_Layout(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "layout"); signal != nil {
 +		return std_widgets.PointerFromQLayout(signal.(func() *std_widgets.QLayout)())
 +	}
 +
 +	return std_widgets.PointerFromQLayout(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).LayoutDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) LayoutDefault() *std_widgets.QLayout {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_widgets.NewQLayoutFromPointer(C.QVBoxLayoutWithTriggerSlot_LayoutDefault(ptr.Pointer()))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_ChildEvent
 +func callbackQVBoxLayoutWithTriggerSlot_ChildEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
 +		signal.(func(*std_core.QChildEvent))(std_core.NewQChildEventFromPointer(e))
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ChildEventDefault(std_core.NewQChildEventFromPointer(e))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) ChildEventDefault(e std_core.QChildEvent_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_ChildEventDefault(ptr.Pointer(), std_core.PointerFromQChildEvent(e))
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_Geometry
 +func callbackQVBoxLayoutWithTriggerSlot_Geometry(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "geometry"); signal != nil {
 +		return std_core.PointerFromQRect(signal.(func() *std_core.QRect)())
 +	}
 +
 +	return std_core.PointerFromQRect(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).GeometryDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) GeometryDefault() *std_core.QRect {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_core.NewQRectFromPointer(C.QVBoxLayoutWithTriggerSlot_GeometryDefault(ptr.Pointer()))
 +		runtime.SetFinalizer(tmpValue, (*std_core.QRect).DestroyQRect)
 +		return tmpValue
 +	}
 +	return nil
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_ControlTypes
 +func callbackQVBoxLayoutWithTriggerSlot_ControlTypes(ptr unsafe.Pointer) C.longlong {
 +	if signal := qt.GetSignal(ptr, "controlTypes"); signal != nil {
 +		return C.longlong(signal.(func() std_widgets.QSizePolicy__ControlType)())
 +	}
 +
 +	return C.longlong(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ControlTypesDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) ControlTypesDefault() std_widgets.QSizePolicy__ControlType {
 +	if ptr.Pointer() != nil {
 +		return std_widgets.QSizePolicy__ControlType(C.QVBoxLayoutWithTriggerSlot_ControlTypesDefault(ptr.Pointer()))
 +	}
 +	return 0
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_IsEmpty
 +func callbackQVBoxLayoutWithTriggerSlot_IsEmpty(ptr unsafe.Pointer) C.char {
 +	if signal := qt.GetSignal(ptr, "isEmpty"); signal != nil {
 +		return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
 +	}
 +
 +	return C.char(int8(qt.GoBoolToInt(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).IsEmptyDefault())))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) IsEmptyDefault() bool {
 +	if ptr.Pointer() != nil {
 +		return C.QVBoxLayoutWithTriggerSlot_IsEmptyDefault(ptr.Pointer()) != 0
 +	}
 +	return false
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_IndexOf
 +func callbackQVBoxLayoutWithTriggerSlot_IndexOf(ptr unsafe.Pointer, widget unsafe.Pointer) C.int {
 +	if signal := qt.GetSignal(ptr, "indexOf"); signal != nil {
 +		return C.int(int32(signal.(func(*std_widgets.QWidget) int)(std_widgets.NewQWidgetFromPointer(widget))))
 +	}
 +
 +	return C.int(int32(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).IndexOfDefault(std_widgets.NewQWidgetFromPointer(widget))))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) IndexOfDefault(widget std_widgets.QWidget_ITF) int {
 +	if ptr.Pointer() != nil {
 +		return int(int32(C.QVBoxLayoutWithTriggerSlot_IndexOfDefault(ptr.Pointer(), std_widgets.PointerFromQWidget(widget))))
 +	}
 +	return 0
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_Event
 +func callbackQVBoxLayoutWithTriggerSlot_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
 +	if signal := qt.GetSignal(ptr, "event"); signal != nil {
 +		return C.char(int8(qt.GoBoolToInt(signal.(func(*std_core.QEvent) bool)(std_core.NewQEventFromPointer(e)))))
 +	}
 +
 +	return C.char(int8(qt.GoBoolToInt(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).EventDefault(std_core.NewQEventFromPointer(e)))))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) EventDefault(e std_core.QEvent_ITF) bool {
 +	if ptr.Pointer() != nil {
 +		return C.QVBoxLayoutWithTriggerSlot_EventDefault(ptr.Pointer(), std_core.PointerFromQEvent(e)) != 0
 +	}
 +	return false
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_EventFilter
 +func callbackQVBoxLayoutWithTriggerSlot_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
 +	if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
 +		return C.char(int8(qt.GoBoolToInt(signal.(func(*std_core.QObject, *std_core.QEvent) bool)(std_core.NewQObjectFromPointer(watched), std_core.NewQEventFromPointer(event)))))
 +	}
 +
 +	return C.char(int8(qt.GoBoolToInt(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).EventFilterDefault(std_core.NewQObjectFromPointer(watched), std_core.NewQEventFromPointer(event)))))
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) EventFilterDefault(watched std_core.QObject_ITF, event std_core.QEvent_ITF) bool {
 +	if ptr.Pointer() != nil {
 +		return C.QVBoxLayoutWithTriggerSlot_EventFilterDefault(ptr.Pointer(), std_core.PointerFromQObject(watched), std_core.PointerFromQEvent(event)) != 0
 +	}
 +	return false
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_ConnectNotify
 +func callbackQVBoxLayoutWithTriggerSlot_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
 +		signal.(func(*std_core.QMetaMethod))(std_core.NewQMetaMethodFromPointer(sign))
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ConnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) ConnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_CustomEvent
 +func callbackQVBoxLayoutWithTriggerSlot_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
 +		signal.(func(*std_core.QEvent))(std_core.NewQEventFromPointer(event))
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).CustomEventDefault(std_core.NewQEventFromPointer(event))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) CustomEventDefault(event std_core.QEvent_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_CustomEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_DeleteLater
 +func callbackQVBoxLayoutWithTriggerSlot_DeleteLater(ptr unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
 +		signal.(func())()
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).DeleteLaterDefault()
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) DeleteLaterDefault() {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_DeleteLaterDefault(ptr.Pointer())
 +		ptr.SetPointer(nil)
 +		runtime.SetFinalizer(ptr, nil)
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_Destroyed
 +func callbackQVBoxLayoutWithTriggerSlot_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
 +		signal.(func(*std_core.QObject))(std_core.NewQObjectFromPointer(obj))
 +	}
 +
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_DisconnectNotify
 +func callbackQVBoxLayoutWithTriggerSlot_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
 +		signal.(func(*std_core.QMetaMethod))(std_core.NewQMetaMethodFromPointer(sign))
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).DisconnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) DisconnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_ObjectNameChanged
 +func callbackQVBoxLayoutWithTriggerSlot_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_Moc_PackedString) {
 +	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
 +		signal.(func(string))(cGoUnpackString(objectName))
 +	}
 +
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_TimerEvent
 +func callbackQVBoxLayoutWithTriggerSlot_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
 +	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
 +		signal.(func(*std_core.QTimerEvent))(std_core.NewQTimerEventFromPointer(event))
 +	} else {
 +		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).TimerEventDefault(std_core.NewQTimerEventFromPointer(event))
 +	}
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) TimerEventDefault(event std_core.QTimerEvent_ITF) {
 +	if ptr.Pointer() != nil {
 +		C.QVBoxLayoutWithTriggerSlot_TimerEventDefault(ptr.Pointer(), std_core.PointerFromQTimerEvent(event))
 +	}
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_SpacerItem
 +func callbackQVBoxLayoutWithTriggerSlot_SpacerItem(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "spacerItem"); signal != nil {
 +		return std_widgets.PointerFromQSpacerItem(signal.(func() *std_widgets.QSpacerItem)())
 +	}
 +
 +	return std_widgets.PointerFromQSpacerItem(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SpacerItemDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) SpacerItemDefault() *std_widgets.QSpacerItem {
 +	if ptr.Pointer() != nil {
 +		return std_widgets.NewQSpacerItemFromPointer(C.QVBoxLayoutWithTriggerSlot_SpacerItemDefault(ptr.Pointer()))
 +	}
 +	return nil
 +}
 +
 +//export callbackQVBoxLayoutWithTriggerSlot_Widget
 +func callbackQVBoxLayoutWithTriggerSlot_Widget(ptr unsafe.Pointer) unsafe.Pointer {
 +	if signal := qt.GetSignal(ptr, "widget"); signal != nil {
 +		return std_widgets.PointerFromQWidget(signal.(func() *std_widgets.QWidget)())
 +	}
 +
 +	return std_widgets.PointerFromQWidget(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).WidgetDefault())
 +}
 +
 +func (ptr *QVBoxLayoutWithTriggerSlot) WidgetDefault() *std_widgets.QWidget {
 +	if ptr.Pointer() != nil {
 +		var tmpValue = std_widgets.NewQWidgetFromPointer(C.QVBoxLayoutWithTriggerSlot_WidgetDefault(ptr.Pointer()))
 +		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
 +			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
 +		}
 +		return tmpValue
 +	}
 +	return nil
 +}
 diff --git a/ui/listLayouts/moc.h b/ui/listLayouts/moc.h
 new file mode 100644
 index 0000000..422cfa2
 --- /dev/null
 +++ b/ui/listLayouts/moc.h
 @@ -0,0 +1,136 @@
 +
 +
 +#pragma once
 +
 +#ifndef GO_MOC_H
 +#define GO_MOC_H
 +
 +#include <stdint.h>
 +
 +#ifdef __cplusplus
 +class QVBoxLayoutWithTriggerSlot;
 +void QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaTypes();
 +class QRoomVBoxLayoutWithTriggerSlot;
 +void QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaTypes();
 +extern "C" {
 +#endif
 +
 +struct Moc_PackedString { char* data; long long len; };
 +struct Moc_PackedList { void* data; long long len; };
 +void QRoomVBoxLayoutWithTriggerSlot_ConnectTriggerRoom(void* ptr);
 +void QRoomVBoxLayoutWithTriggerSlot_DisconnectTriggerRoom(void* ptr);
 +void QRoomVBoxLayoutWithTriggerSlot_TriggerRoom(void* ptr, struct Moc_PackedString roomID);
 +void QRoomVBoxLayoutWithTriggerSlot_ConnectChangeRoom(void* ptr);
 +void QRoomVBoxLayoutWithTriggerSlot_DisconnectChangeRoom(void* ptr);
 +void QRoomVBoxLayoutWithTriggerSlot_ChangeRoom(void* ptr, struct Moc_PackedString roomID);
 +int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType();
 +int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(char* typeName);
 +int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType();
 +int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(char* uri, int versionMajor, int versionMinor, char* qmlName);
 +void* QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(void* ptr, int i);
 +void QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(void* ptr, void* i);
 +void* QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList2(void* ptr, int i);
 +void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList2(void* ptr, void* i);
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList2(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList3(void* ptr, int i);
 +void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList3(void* ptr, void* i);
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList3(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList(void* ptr, int i);
 +void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList(void* ptr, void* i);
 +void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot___children_atList(void* ptr, int i);
 +void QRoomVBoxLayoutWithTriggerSlot___children_setList(void* ptr, void* i);
 +void* QRoomVBoxLayoutWithTriggerSlot___children_newList(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot();
 +void* QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot2(void* parent);
 +void QRoomVBoxLayoutWithTriggerSlot_DestroyQRoomVBoxLayoutWithTriggerSlot(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot_TakeAtDefault(void* ptr, int index);
 +void QRoomVBoxLayoutWithTriggerSlot_AddItemDefault(void* ptr, void* item);
 +void QRoomVBoxLayoutWithTriggerSlot_InvalidateDefault(void* ptr);
 +void QRoomVBoxLayoutWithTriggerSlot_SetGeometryDefault(void* ptr, void* r);
 +void* QRoomVBoxLayoutWithTriggerSlot_ItemAtDefault(void* ptr, int index);
 +void* QRoomVBoxLayoutWithTriggerSlot_MaximumSizeDefault(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot_MinimumSizeDefault(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot_SizeHintDefault(void* ptr);
 +long long QRoomVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(void* ptr);
 +char QRoomVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(void* ptr);
 +int QRoomVBoxLayoutWithTriggerSlot_CountDefault(void* ptr);
 +int QRoomVBoxLayoutWithTriggerSlot_HeightForWidthDefault(void* ptr, int w);
 +int QRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(void* ptr, int w);
 +void* QRoomVBoxLayoutWithTriggerSlot_LayoutDefault(void* ptr);
 +void QRoomVBoxLayoutWithTriggerSlot_ChildEventDefault(void* ptr, void* e);
 +void* QRoomVBoxLayoutWithTriggerSlot_GeometryDefault(void* ptr);
 +long long QRoomVBoxLayoutWithTriggerSlot_ControlTypesDefault(void* ptr);
 +char QRoomVBoxLayoutWithTriggerSlot_IsEmptyDefault(void* ptr);
 +int QRoomVBoxLayoutWithTriggerSlot_IndexOfDefault(void* ptr, void* widget);
 +char QRoomVBoxLayoutWithTriggerSlot_EventDefault(void* ptr, void* e);
 +char QRoomVBoxLayoutWithTriggerSlot_EventFilterDefault(void* ptr, void* watched, void* event);
 +void QRoomVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(void* ptr, void* sign);
 +void QRoomVBoxLayoutWithTriggerSlot_CustomEventDefault(void* ptr, void* event);
 +void QRoomVBoxLayoutWithTriggerSlot_DeleteLaterDefault(void* ptr);
 +void QRoomVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(void* ptr, void* sign);
 +void QRoomVBoxLayoutWithTriggerSlot_TimerEventDefault(void* ptr, void* event);
 +;
 +void* QRoomVBoxLayoutWithTriggerSlot_SpacerItemDefault(void* ptr);
 +void* QRoomVBoxLayoutWithTriggerSlot_WidgetDefault(void* ptr);
 +void QVBoxLayoutWithTriggerSlot_ConnectTriggerMessage(void* ptr);
 +void QVBoxLayoutWithTriggerSlot_DisconnectTriggerMessage(void* ptr);
 +void QVBoxLayoutWithTriggerSlot_TriggerMessage(void* ptr, struct Moc_PackedString messageBody, struct Moc_PackedString sender, long long timestamp);
 +int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType();
 +int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(char* typeName);
 +int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType();
 +int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType2(char* uri, int versionMajor, int versionMinor, char* qmlName);
 +void* QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(void* ptr, int i);
 +void QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(void* ptr, void* i);
 +void* QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot___findChildren_atList2(void* ptr, int i);
 +void QVBoxLayoutWithTriggerSlot___findChildren_setList2(void* ptr, void* i);
 +void* QVBoxLayoutWithTriggerSlot___findChildren_newList2(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot___findChildren_atList3(void* ptr, int i);
 +void QVBoxLayoutWithTriggerSlot___findChildren_setList3(void* ptr, void* i);
 +void* QVBoxLayoutWithTriggerSlot___findChildren_newList3(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot___findChildren_atList(void* ptr, int i);
 +void QVBoxLayoutWithTriggerSlot___findChildren_setList(void* ptr, void* i);
 +void* QVBoxLayoutWithTriggerSlot___findChildren_newList(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot___children_atList(void* ptr, int i);
 +void QVBoxLayoutWithTriggerSlot___children_setList(void* ptr, void* i);
 +void* QVBoxLayoutWithTriggerSlot___children_newList(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot();
 +void* QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot2(void* parent);
 +void QVBoxLayoutWithTriggerSlot_DestroyQVBoxLayoutWithTriggerSlot(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot_TakeAtDefault(void* ptr, int index);
 +void QVBoxLayoutWithTriggerSlot_AddItemDefault(void* ptr, void* item);
 +void QVBoxLayoutWithTriggerSlot_InvalidateDefault(void* ptr);
 +void QVBoxLayoutWithTriggerSlot_SetGeometryDefault(void* ptr, void* r);
 +void* QVBoxLayoutWithTriggerSlot_ItemAtDefault(void* ptr, int index);
 +void* QVBoxLayoutWithTriggerSlot_MaximumSizeDefault(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot_MinimumSizeDefault(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot_SizeHintDefault(void* ptr);
 +long long QVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(void* ptr);
 +char QVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(void* ptr);
 +int QVBoxLayoutWithTriggerSlot_CountDefault(void* ptr);
 +int QVBoxLayoutWithTriggerSlot_HeightForWidthDefault(void* ptr, int w);
 +int QVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(void* ptr, int w);
 +void* QVBoxLayoutWithTriggerSlot_LayoutDefault(void* ptr);
 +void QVBoxLayoutWithTriggerSlot_ChildEventDefault(void* ptr, void* e);
 +void* QVBoxLayoutWithTriggerSlot_GeometryDefault(void* ptr);
 +long long QVBoxLayoutWithTriggerSlot_ControlTypesDefault(void* ptr);
 +char QVBoxLayoutWithTriggerSlot_IsEmptyDefault(void* ptr);
 +int QVBoxLayoutWithTriggerSlot_IndexOfDefault(void* ptr, void* widget);
 +char QVBoxLayoutWithTriggerSlot_EventDefault(void* ptr, void* e);
 +char QVBoxLayoutWithTriggerSlot_EventFilterDefault(void* ptr, void* watched, void* event);
 +void QVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(void* ptr, void* sign);
 +void QVBoxLayoutWithTriggerSlot_CustomEventDefault(void* ptr, void* event);
 +void QVBoxLayoutWithTriggerSlot_DeleteLaterDefault(void* ptr);
 +void QVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(void* ptr, void* sign);
 +void QVBoxLayoutWithTriggerSlot_TimerEventDefault(void* ptr, void* event);
 +;
 +void* QVBoxLayoutWithTriggerSlot_SpacerItemDefault(void* ptr);
 +void* QVBoxLayoutWithTriggerSlot_WidgetDefault(void* ptr);
 +
 +#ifdef __cplusplus
 +}
 +#endif
 +
 +#endif
 \ No newline at end of file
 diff --git a/ui/listLayouts/moc_cgo_windows_windows_386.go b/ui/listLayouts/moc_cgo_windows_windows_386.go
 new file mode 100644
 index 0000000..1a7efe7
 --- /dev/null
 +++ b/ui/listLayouts/moc_cgo_windows_windows_386.go
 @@ -0,0 +1,11 @@
 +package listLayouts
 +
 +/*
 +#cgo CFLAGS: -fno-keep-inline-dllexport -O2 -Wextra -Wall -W -DUNICODE -D_UNICODE -DQT_NO_DEBUG -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DQT_NEEDS_QMAIN
 +#cgo CXXFLAGS: -fno-keep-inline-dllexport -O2 -std=gnu++11 -Wextra -Wall -W -fexceptions -mthreads -DUNICODE -D_UNICODE -DQT_NO_DEBUG -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DQT_NEEDS_QMAIN
 +#cgo CXXFLAGS: -I../../Morpheus -I. -IC:/Qt/Qt5.9.1/5.9.3/mingw53_32/include -IC:/Qt/Qt5.9.1/5.9.3/mingw53_32/include/QtWidgets -IC:/Qt/Qt5.9.1/5.9.3/mingw53_32/include/QtGui -IC:/Qt/Qt5.9.1/5.9.3/mingw53_32/include/QtANGLE -IC:/Qt/Qt5.9.1/5.9.3/mingw53_32/include/QtCore -Irelease -IC:/Qt/Qt5.9.1/5.9.3/mingw53_32/mkspecs/win32-g++
 +#cgo LDFLAGS:        -Wl,-s -Wl,-subsystem,windows -mthreads
 +#cgo LDFLAGS:        -lmingw32 -LC:/Qt/Qt5.9.1/5.9.3/mingw53_32/lib C:/Qt/Qt5.9.1/5.9.3/mingw53_32/lib/libqtmain.a -LC:/utils/my_sql/my_sql/lib -LC:/utils/postgresql/pgsql/lib -lshell32 C:/Qt/Qt5.9.1/5.9.3/mingw53_32/lib/libQt5Widgets.a C:/Qt/Qt5.9.1/5.9.3/mingw53_32/lib/libQt5Gui.a C:/Qt/Qt5.9.1/5.9.3/mingw53_32/lib/libQt5Core.a
 +#cgo LDFLAGS: -Wl,--allow-multiple-definition
 +*/
 +import "C"
 diff --git a/ui/listLayouts/moc_moc.h b/ui/listLayouts/moc_moc.h
 new file mode 100644
 index 0000000..6806399
 --- /dev/null
 +++ b/ui/listLayouts/moc_moc.h
 @@ -0,0 +1,257 @@
 +/****************************************************************************
 +** Meta object code from reading C++ file 'moc.cpp'
 +**
 +** Created by: The Qt Meta Object Compiler version 67 (Qt 5.9.3)
 +**
 +** WARNING! All changes made in this file will be lost!
 +*****************************************************************************/
 +
 +#include <QtCore/qbytearray.h>
 +#include <QtCore/qmetatype.h>
 +#if !defined(Q_MOC_OUTPUT_REVISION)
 +#error "The header file 'moc.cpp' doesn't include <QObject>."
 +#elif Q_MOC_OUTPUT_REVISION != 67
 +#error "This file was generated using the moc from 5.9.3. It"
 +#error "cannot be used with the include files from this version of Qt."
 +#error "(The moc has changed too much.)"
 +#endif
 +
 +QT_BEGIN_MOC_NAMESPACE
 +QT_WARNING_PUSH
 +QT_WARNING_DISABLE_DEPRECATED
 +struct qt_meta_stringdata_QRoomVBoxLayoutWithTriggerSlot_t {
 +    QByteArrayData data[5];
 +    char stringdata0[62];
 +};
 +#define QT_MOC_LITERAL(idx, ofs, len) \
 +    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
 +    qptrdiff(offsetof(qt_meta_stringdata_QRoomVBoxLayoutWithTriggerSlot_t, stringdata0) + ofs \
 +        - idx * sizeof(QByteArrayData)) \
 +    )
 +static const qt_meta_stringdata_QRoomVBoxLayoutWithTriggerSlot_t qt_meta_stringdata_QRoomVBoxLayoutWithTriggerSlot = {
 +    {
 +QT_MOC_LITERAL(0, 0, 30), // "QRoomVBoxLayoutWithTriggerSlot"
 +QT_MOC_LITERAL(1, 31, 11), // "TriggerRoom"
 +QT_MOC_LITERAL(2, 43, 0), // ""
 +QT_MOC_LITERAL(3, 44, 6), // "roomID"
 +QT_MOC_LITERAL(4, 51, 10) // "ChangeRoom"
 +
 +    },
 +    "QRoomVBoxLayoutWithTriggerSlot\0"
 +    "TriggerRoom\0\0roomID\0ChangeRoom"
 +};
 +#undef QT_MOC_LITERAL
 +
 +static const uint qt_meta_data_QRoomVBoxLayoutWithTriggerSlot[] = {
 +
 + // content:
 +       7,       // revision
 +       0,       // classname
 +       0,    0, // classinfo
 +       2,   14, // methods
 +       0,    0, // properties
 +       0,    0, // enums/sets
 +       0,    0, // constructors
 +       0,       // flags
 +       2,       // signalCount
 +
 + // signals: name, argc, parameters, tag, flags
 +       1,    1,   24,    2, 0x06 /* Public */,
 +       4,    1,   27,    2, 0x06 /* Public */,
 +
 + // signals: parameters
 +    QMetaType::Void, QMetaType::QString,    3,
 +    QMetaType::Void, QMetaType::QString,    3,
 +
 +       0        // eod
 +};
 +
 +void QRoomVBoxLayoutWithTriggerSlot::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
 +{
 +    if (_c == QMetaObject::InvokeMetaMethod) {
 +        QRoomVBoxLayoutWithTriggerSlot *_t = static_cast<QRoomVBoxLayoutWithTriggerSlot *>(_o);
 +        Q_UNUSED(_t)
 +        switch (_id) {
 +        case 0: _t->TriggerRoom((*reinterpret_cast< QString(*)>(_a[1]))); break;
 +        case 1: _t->ChangeRoom((*reinterpret_cast< QString(*)>(_a[1]))); break;
 +        default: ;
 +        }
 +    } else if (_c == QMetaObject::IndexOfMethod) {
 +        int *result = reinterpret_cast<int *>(_a[0]);
 +        {
 +            typedef void (QRoomVBoxLayoutWithTriggerSlot::*_t)(QString );
 +            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QRoomVBoxLayoutWithTriggerSlot::TriggerRoom)) {
 +                *result = 0;
 +                return;
 +            }
 +        }
 +        {
 +            typedef void (QRoomVBoxLayoutWithTriggerSlot::*_t)(QString );
 +            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QRoomVBoxLayoutWithTriggerSlot::ChangeRoom)) {
 +                *result = 1;
 +                return;
 +            }
 +        }
 +    }
 +}
 +
 +const QMetaObject QRoomVBoxLayoutWithTriggerSlot::staticMetaObject = {
 +    { &QVBoxLayout::staticMetaObject, qt_meta_stringdata_QRoomVBoxLayoutWithTriggerSlot.data,
 +      qt_meta_data_QRoomVBoxLayoutWithTriggerSlot,  qt_static_metacall, nullptr, nullptr}
 +};
 +
 +
 +const QMetaObject *QRoomVBoxLayoutWithTriggerSlot::metaObject() const
 +{
 +    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
 +}
 +
 +void *QRoomVBoxLayoutWithTriggerSlot::qt_metacast(const char *_clname)
 +{
 +    if (!_clname) return nullptr;
 +    if (!strcmp(_clname, qt_meta_stringdata_QRoomVBoxLayoutWithTriggerSlot.stringdata0))
 +        return static_cast<void*>(this);
 +    return QVBoxLayout::qt_metacast(_clname);
 +}
 +
 +int QRoomVBoxLayoutWithTriggerSlot::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
 +{
 +    _id = QVBoxLayout::qt_metacall(_c, _id, _a);
 +    if (_id < 0)
 +        return _id;
 +    if (_c == QMetaObject::InvokeMetaMethod) {
 +        if (_id < 2)
 +            qt_static_metacall(this, _c, _id, _a);
 +        _id -= 2;
 +    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
 +        if (_id < 2)
 +            *reinterpret_cast<int*>(_a[0]) = -1;
 +        _id -= 2;
 +    }
 +    return _id;
 +}
 +
 +// SIGNAL 0
 +void QRoomVBoxLayoutWithTriggerSlot::TriggerRoom(QString _t1)
 +{
 +    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
 +    QMetaObject::activate(this, &staticMetaObject, 0, _a);
 +}
 +
 +// SIGNAL 1
 +void QRoomVBoxLayoutWithTriggerSlot::ChangeRoom(QString _t1)
 +{
 +    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
 +    QMetaObject::activate(this, &staticMetaObject, 1, _a);
 +}
 +struct qt_meta_stringdata_QVBoxLayoutWithTriggerSlot_t {
 +    QByteArrayData data[6];
 +    char stringdata0[72];
 +};
 +#define QT_MOC_LITERAL(idx, ofs, len) \
 +    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
 +    qptrdiff(offsetof(qt_meta_stringdata_QVBoxLayoutWithTriggerSlot_t, stringdata0) + ofs \
 +        - idx * sizeof(QByteArrayData)) \
 +    )
 +static const qt_meta_stringdata_QVBoxLayoutWithTriggerSlot_t qt_meta_stringdata_QVBoxLayoutWithTriggerSlot = {
 +    {
 +QT_MOC_LITERAL(0, 0, 26), // "QVBoxLayoutWithTriggerSlot"
 +QT_MOC_LITERAL(1, 27, 14), // "TriggerMessage"
 +QT_MOC_LITERAL(2, 42, 0), // ""
 +QT_MOC_LITERAL(3, 43, 11), // "messageBody"
 +QT_MOC_LITERAL(4, 55, 6), // "sender"
 +QT_MOC_LITERAL(5, 62, 9) // "timestamp"
 +
 +    },
 +    "QVBoxLayoutWithTriggerSlot\0TriggerMessage\0"
 +    "\0messageBody\0sender\0timestamp"
 +};
 +#undef QT_MOC_LITERAL
 +
 +static const uint qt_meta_data_QVBoxLayoutWithTriggerSlot[] = {
 +
 + // content:
 +       7,       // revision
 +       0,       // classname
 +       0,    0, // classinfo
 +       1,   14, // methods
 +       0,    0, // properties
 +       0,    0, // enums/sets
 +       0,    0, // constructors
 +       0,       // flags
 +       1,       // signalCount
 +
 + // signals: name, argc, parameters, tag, flags
 +       1,    3,   19,    2, 0x06 /* Public */,
 +
 + // signals: parameters
 +    QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::LongLong,    3,    4,    5,
 +
 +       0        // eod
 +};
 +
 +void QVBoxLayoutWithTriggerSlot::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
 +{
 +    if (_c == QMetaObject::InvokeMetaMethod) {
 +        QVBoxLayoutWithTriggerSlot *_t = static_cast<QVBoxLayoutWithTriggerSlot *>(_o);
 +        Q_UNUSED(_t)
 +        switch (_id) {
 +        case 0: _t->TriggerMessage((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2])),(*reinterpret_cast< qint64(*)>(_a[3]))); break;
 +        default: ;
 +        }
 +    } else if (_c == QMetaObject::IndexOfMethod) {
 +        int *result = reinterpret_cast<int *>(_a[0]);
 +        {
 +            typedef void (QVBoxLayoutWithTriggerSlot::*_t)(QString , QString , qint64 );
 +            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QVBoxLayoutWithTriggerSlot::TriggerMessage)) {
 +                *result = 0;
 +                return;
 +            }
 +        }
 +    }
 +}
 +
 +const QMetaObject QVBoxLayoutWithTriggerSlot::staticMetaObject = {
 +    { &QVBoxLayout::staticMetaObject, qt_meta_stringdata_QVBoxLayoutWithTriggerSlot.data,
 +      qt_meta_data_QVBoxLayoutWithTriggerSlot,  qt_static_metacall, nullptr, nullptr}
 +};
 +
 +
 +const QMetaObject *QVBoxLayoutWithTriggerSlot::metaObject() const
 +{
 +    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
 +}
 +
 +void *QVBoxLayoutWithTriggerSlot::qt_metacast(const char *_clname)
 +{
 +    if (!_clname) return nullptr;
 +    if (!strcmp(_clname, qt_meta_stringdata_QVBoxLayoutWithTriggerSlot.stringdata0))
 +        return static_cast<void*>(this);
 +    return QVBoxLayout::qt_metacast(_clname);
 +}
 +
 +int QVBoxLayoutWithTriggerSlot::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
 +{
 +    _id = QVBoxLayout::qt_metacall(_c, _id, _a);
 +    if (_id < 0)
 +        return _id;
 +    if (_c == QMetaObject::InvokeMetaMethod) {
 +        if (_id < 1)
 +            qt_static_metacall(this, _c, _id, _a);
 +        _id -= 1;
 +    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
 +        if (_id < 1)
 +            *reinterpret_cast<int*>(_a[0]) = -1;
 +        _id -= 1;
 +    }
 +    return _id;
 +}
 +
 +// SIGNAL 0
 +void QVBoxLayoutWithTriggerSlot::TriggerMessage(QString _t1, QString _t2, qint64 _t3)
 +{
 +    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
 +    QMetaObject::activate(this, &staticMetaObject, 0, _a);
 +}
 +QT_WARNING_POP
 +QT_END_MOC_NAMESPACE
 diff --git a/ui/roomlist.go b/ui/listLayouts/roomlist.go
 similarity index 62%
 rename from ui/roomlist.go
 rename to ui/listLayouts/roomlist.go
 index 0664703..5774889 100644
 --- a/ui/roomlist.go
 +++ b/ui/listLayouts/roomlist.go
 @@ -1,7 +1,8 @@
 -package ui
 +package listLayouts
  
  import (
 -	"github.com/Nordgedanken/Morpheus/matrix"
 +	"github.com/Nordgedanken/Morpheus/matrix/rooms"
 +	log "github.com/sirupsen/logrus"
  	"github.com/therecipe/qt/core"
  	"github.com/therecipe/qt/gui"
  	"github.com/therecipe/qt/uitools"
 @@ -23,25 +24,24 @@ import (
  type QRoomVBoxLayoutWithTriggerSlot struct {
  	widgets.QVBoxLayout
  
 -	_ func(roomID string) `slot:"TriggerRoom"`
 -	_ func(url *core.QUrl) `slot:"ChangeRoom"`
 +	_ func(roomID string) `signal:"TriggerRoom"`
 +	_ func(roomID string) `signal:"ChangeRoom"`
  }
  
  // NewRoomList generates a new QRoomVBoxLayoutWithTriggerSlot and adds it to the room scrollArea
 -func NewRoomList(scrollArea *widgets.QScrollArea, roomView *widgets.QWidget) (roomViewLayout *QRoomVBoxLayoutWithTriggerSlot) {
 -	roomViewLayout = NewQRoomVBoxLayoutWithTriggerSlot2(roomView)
 +func NewRoomList(scrollArea *widgets.QScrollArea) (roomViewLayout *QRoomVBoxLayoutWithTriggerSlot) {
 +	roomViewLayout = NewQRoomVBoxLayoutWithTriggerSlot2(scrollArea.Widget())
  
  	roomViewLayout.SetSpacing(0)
  	roomViewLayout.SetContentsMargins(0, 0, 0, 0)
 -	roomView.SetContentsMargins(0, 0, 0, 0)
 -	scrollArea.SetWidget(roomView)
 +	scrollArea.Widget().SetContentsMargins(0, 0, 0, 0)
  	scrollArea.Widget().SetLayout(roomViewLayout)
  
  	return
  }
  
  // NewRoom adds a new room object to the view
 -func (roomViewLayout *QRoomVBoxLayoutWithTriggerSlot) NewRoom(room *matrix.Room, scrollArea *widgets.QScrollArea, mainUIStruct *MainUI) (err error) {
 +func (roomViewLayout *QRoomVBoxLayoutWithTriggerSlot) NewRoom(room *rooms.Room, scrollArea *widgets.QScrollArea) (err error) {
  	roomAvatar, roomAvatarErr := room.GetRoomAvatar()
  	if roomAvatarErr != nil {
  		err = roomAvatarErr
 @@ -61,42 +61,38 @@ func (roomViewLayout *QRoomVBoxLayoutWithTriggerSlot) NewRoom(room *matrix.Room,
  	roomName := widgets.NewQLabelFromPointer(widget.FindChild("roomName", core.Qt__FindChildrenRecursively).Pointer())
  	/*lastMessageContent := widgets.NewQLabelFromPointer(widget.FindChild("lastMessage", core.Qt__FindChildrenRecursively).Pointer())*/
  
 -	roomAvatarQLabel.SetPixmap(roomAvatar)
 -	roomName.SetText(room.GetRoomName())
 +	roomAvatarQLabel.ConnectSetPixmap(func(vqp *gui.QPixmap) {
 +		log.Println("SetPixmapEventRoomAvatar")
  
 -	/*
 -		messageContent.SetText(markdownMessage)
 +		vqp.Scaled2(roomAvatarQLabel.Width(), roomAvatarQLabel.Height(), 0, 0)
  
 -		messageContent.SetMinimumWidth(messageContent.LineWidth())
 +		newPixmap := gui.NewQPixmap3(2*roomAvatarQLabel.Width(), 2*roomAvatarQLabel.Height())
 +		newPixmap.Fill(nil)
  
 -		roomWidget.SetMinimumWidth(messageContent.LineWidth() + 100)
 -	*/
 -	widget.Resize(wrapperWidget.Size())
 +		painter := gui.NewQPainter2(newPixmap)
  
 -	var filterObject = core.NewQObject(nil)
 -	filterObject.ConnectEventFilter(func(watched *core.QObject, event *core.QEvent) bool {
 -		if event.Type() == core.QEvent__MouseButtonPress {
 -			var mouseEvent = gui.NewQMouseEventFromPointer(event.Pointer())
 +		r := gui.NewQRegion2(roomAvatarQLabel.Width()/2, roomAvatarQLabel.Height()/2, roomAvatarQLabel.Width(), roomAvatarQLabel.Height(), gui.QRegion__Ellipse)
  
 -			if mouseEvent.Button() == core.Qt__LeftButton {
 -				if mainUIStruct.currentRoom != room.RoomID {
 -					mainUIStruct.SetCurrentRoom(room.RoomID)
 -					mainUIStruct.MainWidget.SetWindowTitle("Morpheus - " + room.GetRoomTopic())
 +		painter.SetClipRegion(r, 0)
  
 -					mainUIStruct.RoomAvatar.SetPixmap(roomAvatar)
 +		painter.DrawPixmap10(roomAvatarQLabel.Rect(), vqp)
 +		newImage := newPixmap.ToImage()
 +		vqp.FromImage(newImage, 0)
 +	})
  
 -					mainUIStruct.RoomTitle.SetText(room.GetRoomName())
 +	roomAvatarQLabel.SetPixmap(roomAvatar)
 +	roomName.SetText(room.GetRoomName())
  
 -					mainUIStruct.RoomTopic.SetText(room.GetRoomTopic())
 -					count := mainUIStruct.MessageListLayout.Count()
 -					for i := 0; i < count; i++ {
 -						widgetScroll := mainUIStruct.MessageListLayout.ItemAt(i).Widget()
 -						widgetScroll.DeleteLater()
 -					}
 +	wrapperWidget.Resize2(scrollArea.Widget().Size().Width(), wrapperWidget.Size().Height())
 +	widget.Resize2(scrollArea.Widget().Size().Width(), wrapperWidget.Size().Height())
  
 -					go mainUIStruct.loadCache()
 -			}
 +	var filterObject = core.NewQObject(nil)
 +	filterObject.ConnectEventFilter(func(watched *core.QObject, event *core.QEvent) bool {
 +		if event.Type() == core.QEvent__MouseButtonPress {
 +			var mouseEvent = gui.NewQMouseEventFromPointer(event.Pointer())
  
 +			if mouseEvent.Button() == core.Qt__LeftButton {
 +				go roomViewLayout.ChangeRoom(room.RoomID)
  				return true
  			}
  
 @@ -112,6 +108,9 @@ func (roomViewLayout *QRoomVBoxLayoutWithTriggerSlot) NewRoom(room *matrix.Room,
  	wrapperWidget.InstallEventFilter(filterObject)
  
  	roomViewLayout.InsertWidget(roomViewLayout.Count()+1, wrapperWidget, 0, 0)
 +	scrollArea.SetWidgetResizable(true)
 +	scrollArea.Resize2(wrapperWidget.Size().Width(), scrollArea.Widget().Size().Height())
 +	scrollArea.Widget().Resize2(wrapperWidget.Size().Width(), scrollArea.Widget().Size().Height())
  
  	return
  }
 diff --git a/ui/types.go b/ui/types.go
 index ea32e62..7364a0f 100644
 --- a/ui/types.go
 +++ b/ui/types.go
 @@ -1,70 +1,36 @@
  package ui
  
  import (
 -	"github.com/Nordgedanken/Morpheus/matrix"
 -	"github.com/Nordgedanken/Morpheus/matrix/db"
 +	"github.com/Nordgedanken/Morpheus/matrix/globalTypes"
  	"github.com/Nordgedanken/Morpheus/matrix/syncer"
 -	"github.com/matrix-org/gomatrix"
  	"github.com/therecipe/qt/widgets"
  )
  
 -// Config holds important reused information in the UI
 -type config struct {
 -	username string
 -	password string
 -
 -	windowWidth  int
 -	windowHeight int
 -
 -	matrixClient
 -}
 -
 -type matrixClient struct {
 -	databases
 -	cli    *gomatrix.Client
 -	syncer *syncer.MorpheusSyncer
 -}
 -
 -// GetCli returns the Matrix Client
 -func (mc *matrixClient) GetCli() *gomatrix.Client{
 -	return mc.cli
 -}
 -
 -type databases struct {
 -	cacheDB db.Storer
 -}
 -
 -// SetCurrentRoom sets the new room ID of the MainUI
 -func (d *databases) SetCacheDB(db db.Storer) {
 -	d.cacheDB = db
 -}
 -
  // MainUI holds information about the MainUI
  type MainUI struct {
 -	config
 +	globalTypes.Config
  
  	widget            *widgets.QWidget
  	RoomAvatar        *widgets.QLabel
  	RoomTitle         *widgets.QLabel
  	RoomTopic         *widgets.QLabel
  	MainWidget        *widgets.QWidget
 -	MessageListLayout *QVBoxLayoutWithTriggerSlot
  	messageScrollArea *widgets.QScrollArea
 +	roomScrollArea    *widgets.QScrollArea
  
 -	window      *widgets.QMainWindow
 -	storage     *syncer.MorpheusStore
 -	rooms       map[string]*matrix.Room
 -	currentRoom string
 +	window  *widgets.QMainWindow
 +	storage *syncer.MorpheusStore
  }
  
  // SetCurrentRoom sets the new room ID of the MainUI
  func (m *MainUI) SetCurrentRoom(RoomID string) {
 -	m.currentRoom = RoomID
 +	m.CurrentRoom = RoomID
  }
  
  // LoginUI holds information about the LoginUI
  type LoginUI struct {
 -	config
 +	globalTypes.Config
 +
  	LoginWidget *widgets.QWidget
  	widget      *widgets.QWidget
  	window      *widgets.QMainWindow