morpheus

commit 45c1afefd33dd05b127492e1b9b75887eac72daf
parent 2ac0529201fe54ba801d55d4f70af02abf783343
Author: MTRNord <mtrnord1@gmail.com>
Date:   Wed, 18 Oct 2017 15:11:30 +0200

Prevent having nil pointer issue with senderDisplayName, modify messageWidget design, add missing event.Accept(), Prepare code for framelessWindow

Signed-off-by: MTRNord <mtrnord1@gmail.com>

Diffstat:
M
elements/messageList.go
 | 
11
+++++++++--
M
elements/moc.cpp
 | 
348
++++++++++++++++++++++++++++++++++++++++----------------------------------------
M
elements/moc.go
 | 
872
++++++++++++++++++++++++++++++++++++++++----------------------------------------
M
main.go
 | 
18
++++++++++++++++++
M
qml/ui/chat.ui
 | 
5
++++-
M
qml/ui/message.ui
 | 
96
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------------
M
ui/MainUI.go
 | 
7
+++++--

7 files changed, 716 insertions(+), 641 deletions(-)
diff --git a/elements/messageList.go b/elements/messageList.go
@@ -68,8 +68,15 @@ func (messageViewLayout *QVBoxLayoutWithTriggerSlot) NewMessage(body string, cli
 	messageContent.SetText(markdownMessage)
 
 	senderDisplayNameResp, _ := cli.GetDisplayName(sender)
-	fmt.Println(senderDisplayNameResp)
-	senderDisplayName := senderDisplayNameResp.DisplayName
+	var senderDisplayName string
+	if senderDisplayNameResp == nil {
+		senderDisplayName = sender
+	} else if senderDisplayNameResp.DisplayName == "" {
+		senderDisplayName = sender
+	} else {
+		senderDisplayName = senderDisplayNameResp.DisplayName
+	}
+	fmt.Println(senderDisplayName)
 	senderContent.SetText(senderDisplayName)
 	avatarLogo.SetPixmap(avatar)
 
diff --git a/elements/moc.cpp b/elements/moc.cpp
@@ -125,544 +125,544 @@ Q_DECLARE_METATYPE(QVBoxLayoutWithTriggerSlot*)
 void QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaTypes() {
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_TriggerMessage(void* ptr, struct Moc_PackedString messageBody, struct Moc_PackedString sender)
+void QVBoxLayoutWithTriggerSlot_TriggerMessage(void* ptr, struct Moc_PackedString messageBody, struct Moc_PackedString sender)
 {
-	QMetaObject::invokeMethod(static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), "TriggerMessage", Q_ARG(QString, QString::fromUtf8(messageBody.data, messageBody.len)), Q_ARG(QString, QString::fromUtf8(sender.data, sender.len)));
+	QMetaObject::invokeMethod(static_cast<QVBoxLayoutWithTriggerSlot*>(ptr), "TriggerMessage", Q_ARG(QString, QString::fromUtf8(messageBody.data, messageBody.len)), Q_ARG(QString, QString::fromUtf8(sender.data, sender.len)));
 }
 
-int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()
+int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()
 {
-	return qRegisterMetaType<QRoomVBoxLayoutWithTriggerSlot*>();
+	return qRegisterMetaType<QVBoxLayoutWithTriggerSlot*>();
 }
 
-int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(char* typeName)
+int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(char* typeName)
 {
-	return qRegisterMetaType<QRoomVBoxLayoutWithTriggerSlot*>(const_cast<const char*>(typeName));
+	return qRegisterMetaType<QVBoxLayoutWithTriggerSlot*>(const_cast<const char*>(typeName));
 }
 
-int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()
+int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()
 {
 #ifdef QT_QML_LIB
-	return qmlRegisterType<QRoomVBoxLayoutWithTriggerSlot>();
+	return qmlRegisterType<QVBoxLayoutWithTriggerSlot>();
 #else
 	return 0;
 #endif
 }
 
-int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(char* uri, int versionMajor, int versionMinor, char* qmlName)
+int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_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));
+	return qmlRegisterType<QVBoxLayoutWithTriggerSlot>(const_cast<const char*>(uri), versionMajor, versionMinor, const_cast<const char*>(qmlName));
 #else
 	return 0;
 #endif
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(void* ptr, int i)
+void* QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(void* ptr, int i)
 {
 	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
 }
 
-void QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(void* ptr, void* i)
+void QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(void* ptr, void* i)
 {
 	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(void* ptr)
+void* QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QByteArray>;
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList2(void* ptr, int i)
+void* QVBoxLayoutWithTriggerSlot___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)
+void QVBoxLayoutWithTriggerSlot___findChildren_setList2(void* ptr, void* i)
 {
 	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList2(void* ptr)
+void* QVBoxLayoutWithTriggerSlot___findChildren_newList2(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QObject*>;
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList3(void* ptr, int i)
+void* QVBoxLayoutWithTriggerSlot___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)
+void QVBoxLayoutWithTriggerSlot___findChildren_setList3(void* ptr, void* i)
 {
 	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList3(void* ptr)
+void* QVBoxLayoutWithTriggerSlot___findChildren_newList3(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QObject*>;
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___findChildren_atList(void* ptr, int i)
+void* QVBoxLayoutWithTriggerSlot___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)
+void QVBoxLayoutWithTriggerSlot___findChildren_setList(void* ptr, void* i)
 {
 	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList(void* ptr)
+void* QVBoxLayoutWithTriggerSlot___findChildren_newList(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QObject*>;
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___children_atList(void* ptr, int i)
+void* QVBoxLayoutWithTriggerSlot___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)
+void QVBoxLayoutWithTriggerSlot___children_setList(void* ptr, void* i)
 {
 	static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot___children_newList(void* ptr)
+void* QVBoxLayoutWithTriggerSlot___children_newList(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QObject *>;
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot()
+void* QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot()
 {
-	return new QRoomVBoxLayoutWithTriggerSlot();
+	return new QVBoxLayoutWithTriggerSlot();
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot2(void* parent)
+void* QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot2(void* parent)
 {
-		return new QRoomVBoxLayoutWithTriggerSlot(static_cast<QWidget*>(parent));
+		return new QVBoxLayoutWithTriggerSlot(static_cast<QWidget*>(parent));
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_DestroyQRoomVBoxLayoutWithTriggerSlot(void* ptr)
+void QVBoxLayoutWithTriggerSlot_DestroyQVBoxLayoutWithTriggerSlot(void* ptr)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->~QRoomVBoxLayoutWithTriggerSlot();
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->~QVBoxLayoutWithTriggerSlot();
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_TakeAtDefault(void* ptr, int index)
+void* QVBoxLayoutWithTriggerSlot_TakeAtDefault(void* ptr, int index)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::takeAt(index);
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::takeAt(index);
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_AddItemDefault(void* ptr, void* item)
+void QVBoxLayoutWithTriggerSlot_AddItemDefault(void* ptr, void* item)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::addItem(static_cast<QLayoutItem*>(item));
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::addItem(static_cast<QLayoutItem*>(item));
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_InvalidateDefault(void* ptr)
+void QVBoxLayoutWithTriggerSlot_InvalidateDefault(void* ptr)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::invalidate();
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::invalidate();
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_SetGeometryDefault(void* ptr, void* r)
+void QVBoxLayoutWithTriggerSlot_SetGeometryDefault(void* ptr, void* r)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::setGeometry(*static_cast<QRect*>(r));
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::setGeometry(*static_cast<QRect*>(r));
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_ItemAtDefault(void* ptr, int index)
+void* QVBoxLayoutWithTriggerSlot_ItemAtDefault(void* ptr, int index)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::itemAt(index);
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::itemAt(index);
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_MaximumSizeDefault(void* ptr)
+void* QVBoxLayoutWithTriggerSlot_MaximumSizeDefault(void* ptr)
 {
-	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
+	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_MinimumSizeDefault(void* ptr)
+void* QVBoxLayoutWithTriggerSlot_MinimumSizeDefault(void* ptr)
 {
-	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
+	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_SizeHintDefault(void* ptr)
+void* QVBoxLayoutWithTriggerSlot_SizeHintDefault(void* ptr)
 {
-	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
+	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
 }
 
-long long QRoomVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(void* ptr)
+long long QVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(void* ptr)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::expandingDirections();
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::expandingDirections();
 }
 
-char QRoomVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(void* ptr)
+char QVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(void* ptr)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::hasHeightForWidth();
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::hasHeightForWidth();
 }
 
-int QRoomVBoxLayoutWithTriggerSlot_CountDefault(void* ptr)
+int QVBoxLayoutWithTriggerSlot_CountDefault(void* ptr)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::count();
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::count();
 }
 
-int QRoomVBoxLayoutWithTriggerSlot_HeightForWidthDefault(void* ptr, int w)
+int QVBoxLayoutWithTriggerSlot_HeightForWidthDefault(void* ptr, int w)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::heightForWidth(w);
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::heightForWidth(w);
 }
 
-int QRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(void* ptr, int w)
+int QVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(void* ptr, int w)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumHeightForWidth(w);
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumHeightForWidth(w);
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_LayoutDefault(void* ptr)
+void* QVBoxLayoutWithTriggerSlot_LayoutDefault(void* ptr)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::layout();
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::layout();
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_ChildEventDefault(void* ptr, void* e)
+void QVBoxLayoutWithTriggerSlot_ChildEventDefault(void* ptr, void* e)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::childEvent(static_cast<QChildEvent*>(e));
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::childEvent(static_cast<QChildEvent*>(e));
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_GeometryDefault(void* ptr)
+void* QVBoxLayoutWithTriggerSlot_GeometryDefault(void* ptr)
 {
-	return ({ QRect tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
+	return ({ QRect tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
 }
 
-long long QRoomVBoxLayoutWithTriggerSlot_ControlTypesDefault(void* ptr)
+long long QVBoxLayoutWithTriggerSlot_ControlTypesDefault(void* ptr)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::controlTypes();
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::controlTypes();
 }
 
-char QRoomVBoxLayoutWithTriggerSlot_IsEmptyDefault(void* ptr)
+char QVBoxLayoutWithTriggerSlot_IsEmptyDefault(void* ptr)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::isEmpty();
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::isEmpty();
 }
 
-int QRoomVBoxLayoutWithTriggerSlot_IndexOfDefault(void* ptr, void* widget)
+int QVBoxLayoutWithTriggerSlot_IndexOfDefault(void* ptr, void* widget)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::indexOf(static_cast<QWidget*>(widget));
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::indexOf(static_cast<QWidget*>(widget));
 }
 
-char QRoomVBoxLayoutWithTriggerSlot_EventDefault(void* ptr, void* e)
+char QVBoxLayoutWithTriggerSlot_EventDefault(void* ptr, void* e)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
 }
 
-char QRoomVBoxLayoutWithTriggerSlot_EventFilterDefault(void* ptr, void* watched, void* event)
+char QVBoxLayoutWithTriggerSlot_EventFilterDefault(void* ptr, void* watched, void* event)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(void* ptr, void* sign)
+void QVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(void* ptr, void* sign)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_CustomEventDefault(void* ptr, void* event)
+void QVBoxLayoutWithTriggerSlot_CustomEventDefault(void* ptr, void* event)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::customEvent(static_cast<QEvent*>(event));
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::customEvent(static_cast<QEvent*>(event));
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_DeleteLaterDefault(void* ptr)
+void QVBoxLayoutWithTriggerSlot_DeleteLaterDefault(void* ptr)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::deleteLater();
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::deleteLater();
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(void* ptr, void* sign)
+void QVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(void* ptr, void* sign)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
 }
 
-void QRoomVBoxLayoutWithTriggerSlot_TimerEventDefault(void* ptr, void* event)
+void QVBoxLayoutWithTriggerSlot_TimerEventDefault(void* ptr, void* event)
 {
-	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
+	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
 }
 
 
 
-void* QRoomVBoxLayoutWithTriggerSlot_SpacerItemDefault(void* ptr)
+void* QVBoxLayoutWithTriggerSlot_SpacerItemDefault(void* ptr)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::spacerItem();
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::spacerItem();
 }
 
-void* QRoomVBoxLayoutWithTriggerSlot_WidgetDefault(void* ptr)
+void* QVBoxLayoutWithTriggerSlot_WidgetDefault(void* ptr)
 {
-	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::widget();
+	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::widget();
 }
 
-void QVBoxLayoutWithTriggerSlot_TriggerMessage(void* ptr, struct Moc_PackedString messageBody, struct Moc_PackedString sender)
+void QRoomVBoxLayoutWithTriggerSlot_TriggerMessage(void* ptr, struct Moc_PackedString messageBody, struct Moc_PackedString sender)
 {
-	QMetaObject::invokeMethod(static_cast<QVBoxLayoutWithTriggerSlot*>(ptr), "TriggerMessage", Q_ARG(QString, QString::fromUtf8(messageBody.data, messageBody.len)), Q_ARG(QString, QString::fromUtf8(sender.data, sender.len)));
+	QMetaObject::invokeMethod(static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr), "TriggerMessage", Q_ARG(QString, QString::fromUtf8(messageBody.data, messageBody.len)), Q_ARG(QString, QString::fromUtf8(sender.data, sender.len)));
 }
 
-int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()
+int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()
 {
-	return qRegisterMetaType<QVBoxLayoutWithTriggerSlot*>();
+	return qRegisterMetaType<QRoomVBoxLayoutWithTriggerSlot*>();
 }
 
-int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(char* typeName)
+int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(char* typeName)
 {
-	return qRegisterMetaType<QVBoxLayoutWithTriggerSlot*>(const_cast<const char*>(typeName));
+	return qRegisterMetaType<QRoomVBoxLayoutWithTriggerSlot*>(const_cast<const char*>(typeName));
 }
 
-int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()
+int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()
 {
 #ifdef QT_QML_LIB
-	return qmlRegisterType<QVBoxLayoutWithTriggerSlot>();
+	return qmlRegisterType<QRoomVBoxLayoutWithTriggerSlot>();
 #else
 	return 0;
 #endif
 }
 
-int QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType2(char* uri, int versionMajor, int versionMinor, char* qmlName)
+int QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_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));
+	return qmlRegisterType<QRoomVBoxLayoutWithTriggerSlot>(const_cast<const char*>(uri), versionMajor, versionMinor, const_cast<const char*>(qmlName));
 #else
 	return 0;
 #endif
 }
 
-void* QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(void* ptr, int i)
+void* QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_atList(void* ptr, int i)
 {
 	return new QByteArray(static_cast<QList<QByteArray>*>(ptr)->at(i));
 }
 
-void QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(void* ptr, void* i)
+void QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(void* ptr, void* i)
 {
 	static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
 }
 
-void* QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QByteArray>;
 }
 
-void* QVBoxLayoutWithTriggerSlot___findChildren_atList2(void* ptr, int i)
+void* QRoomVBoxLayoutWithTriggerSlot___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)
+void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList2(void* ptr, void* i)
 {
 	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 }
 
-void* QVBoxLayoutWithTriggerSlot___findChildren_newList2(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList2(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QObject*>;
 }
 
-void* QVBoxLayoutWithTriggerSlot___findChildren_atList3(void* ptr, int i)
+void* QRoomVBoxLayoutWithTriggerSlot___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)
+void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList3(void* ptr, void* i)
 {
 	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 }
 
-void* QVBoxLayoutWithTriggerSlot___findChildren_newList3(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList3(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QObject*>;
 }
 
-void* QVBoxLayoutWithTriggerSlot___findChildren_atList(void* ptr, int i)
+void* QRoomVBoxLayoutWithTriggerSlot___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)
+void QRoomVBoxLayoutWithTriggerSlot___findChildren_setList(void* ptr, void* i)
 {
 	static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
 }
 
-void* QVBoxLayoutWithTriggerSlot___findChildren_newList(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot___findChildren_newList(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QObject*>;
 }
 
-void* QVBoxLayoutWithTriggerSlot___children_atList(void* ptr, int i)
+void* QRoomVBoxLayoutWithTriggerSlot___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)
+void QRoomVBoxLayoutWithTriggerSlot___children_setList(void* ptr, void* i)
 {
 	static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
 }
 
-void* QVBoxLayoutWithTriggerSlot___children_newList(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot___children_newList(void* ptr)
 {
 	Q_UNUSED(ptr);
 	return new QList<QObject *>;
 }
 
-void* QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot()
+void* QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot()
 {
-	return new QVBoxLayoutWithTriggerSlot();
+	return new QRoomVBoxLayoutWithTriggerSlot();
 }
 
-void* QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot2(void* parent)
+void* QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot2(void* parent)
 {
-		return new QVBoxLayoutWithTriggerSlot(static_cast<QWidget*>(parent));
+		return new QRoomVBoxLayoutWithTriggerSlot(static_cast<QWidget*>(parent));
 }
 
-void QVBoxLayoutWithTriggerSlot_DestroyQVBoxLayoutWithTriggerSlot(void* ptr)
+void QRoomVBoxLayoutWithTriggerSlot_DestroyQRoomVBoxLayoutWithTriggerSlot(void* ptr)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->~QVBoxLayoutWithTriggerSlot();
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->~QRoomVBoxLayoutWithTriggerSlot();
 }
 
-void* QVBoxLayoutWithTriggerSlot_TakeAtDefault(void* ptr, int index)
+void* QRoomVBoxLayoutWithTriggerSlot_TakeAtDefault(void* ptr, int index)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::takeAt(index);
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::takeAt(index);
 }
 
-void QVBoxLayoutWithTriggerSlot_AddItemDefault(void* ptr, void* item)
+void QRoomVBoxLayoutWithTriggerSlot_AddItemDefault(void* ptr, void* item)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::addItem(static_cast<QLayoutItem*>(item));
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::addItem(static_cast<QLayoutItem*>(item));
 }
 
-void QVBoxLayoutWithTriggerSlot_InvalidateDefault(void* ptr)
+void QRoomVBoxLayoutWithTriggerSlot_InvalidateDefault(void* ptr)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::invalidate();
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::invalidate();
 }
 
-void QVBoxLayoutWithTriggerSlot_SetGeometryDefault(void* ptr, void* r)
+void QRoomVBoxLayoutWithTriggerSlot_SetGeometryDefault(void* ptr, void* r)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::setGeometry(*static_cast<QRect*>(r));
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::setGeometry(*static_cast<QRect*>(r));
 }
 
-void* QVBoxLayoutWithTriggerSlot_ItemAtDefault(void* ptr, int index)
+void* QRoomVBoxLayoutWithTriggerSlot_ItemAtDefault(void* ptr, int index)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::itemAt(index);
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::itemAt(index);
 }
 
-void* QVBoxLayoutWithTriggerSlot_MaximumSizeDefault(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot_MaximumSizeDefault(void* ptr)
 {
-	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
+	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::maximumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
 }
 
-void* QVBoxLayoutWithTriggerSlot_MinimumSizeDefault(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot_MinimumSizeDefault(void* ptr)
 {
-	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
+	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumSize(); new QSize(tmpValue.width(), tmpValue.height()); });
 }
 
-void* QVBoxLayoutWithTriggerSlot_SizeHintDefault(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot_SizeHintDefault(void* ptr)
 {
-	return ({ QSize tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
+	return ({ QSize tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
 }
 
-long long QVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(void* ptr)
+long long QRoomVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(void* ptr)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::expandingDirections();
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::expandingDirections();
 }
 
-char QVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(void* ptr)
+char QRoomVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(void* ptr)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::hasHeightForWidth();
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::hasHeightForWidth();
 }
 
-int QVBoxLayoutWithTriggerSlot_CountDefault(void* ptr)
+int QRoomVBoxLayoutWithTriggerSlot_CountDefault(void* ptr)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::count();
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::count();
 }
 
-int QVBoxLayoutWithTriggerSlot_HeightForWidthDefault(void* ptr, int w)
+int QRoomVBoxLayoutWithTriggerSlot_HeightForWidthDefault(void* ptr, int w)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::heightForWidth(w);
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::heightForWidth(w);
 }
 
-int QVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(void* ptr, int w)
+int QRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(void* ptr, int w)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumHeightForWidth(w);
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::minimumHeightForWidth(w);
 }
 
-void* QVBoxLayoutWithTriggerSlot_LayoutDefault(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot_LayoutDefault(void* ptr)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::layout();
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::layout();
 }
 
-void QVBoxLayoutWithTriggerSlot_ChildEventDefault(void* ptr, void* e)
+void QRoomVBoxLayoutWithTriggerSlot_ChildEventDefault(void* ptr, void* e)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::childEvent(static_cast<QChildEvent*>(e));
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::childEvent(static_cast<QChildEvent*>(e));
 }
 
-void* QVBoxLayoutWithTriggerSlot_GeometryDefault(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot_GeometryDefault(void* ptr)
 {
-	return ({ QRect tmpValue = static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
+	return ({ QRect tmpValue = static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::geometry(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
 }
 
-long long QVBoxLayoutWithTriggerSlot_ControlTypesDefault(void* ptr)
+long long QRoomVBoxLayoutWithTriggerSlot_ControlTypesDefault(void* ptr)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::controlTypes();
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::controlTypes();
 }
 
-char QVBoxLayoutWithTriggerSlot_IsEmptyDefault(void* ptr)
+char QRoomVBoxLayoutWithTriggerSlot_IsEmptyDefault(void* ptr)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::isEmpty();
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::isEmpty();
 }
 
-int QVBoxLayoutWithTriggerSlot_IndexOfDefault(void* ptr, void* widget)
+int QRoomVBoxLayoutWithTriggerSlot_IndexOfDefault(void* ptr, void* widget)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::indexOf(static_cast<QWidget*>(widget));
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::indexOf(static_cast<QWidget*>(widget));
 }
 
-char QVBoxLayoutWithTriggerSlot_EventDefault(void* ptr, void* e)
+char QRoomVBoxLayoutWithTriggerSlot_EventDefault(void* ptr, void* e)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::event(static_cast<QEvent*>(e));
 }
 
-char QVBoxLayoutWithTriggerSlot_EventFilterDefault(void* ptr, void* watched, void* event)
+char QRoomVBoxLayoutWithTriggerSlot_EventFilterDefault(void* ptr, void* watched, void* event)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
 }
 
-void QVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(void* ptr, void* sign)
+void QRoomVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(void* ptr, void* sign)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::connectNotify(*static_cast<QMetaMethod*>(sign));
 }
 
-void QVBoxLayoutWithTriggerSlot_CustomEventDefault(void* ptr, void* event)
+void QRoomVBoxLayoutWithTriggerSlot_CustomEventDefault(void* ptr, void* event)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::customEvent(static_cast<QEvent*>(event));
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::customEvent(static_cast<QEvent*>(event));
 }
 
-void QVBoxLayoutWithTriggerSlot_DeleteLaterDefault(void* ptr)
+void QRoomVBoxLayoutWithTriggerSlot_DeleteLaterDefault(void* ptr)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::deleteLater();
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::deleteLater();
 }
 
-void QVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(void* ptr, void* sign)
+void QRoomVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(void* ptr, void* sign)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::disconnectNotify(*static_cast<QMetaMethod*>(sign));
 }
 
-void QVBoxLayoutWithTriggerSlot_TimerEventDefault(void* ptr, void* event)
+void QRoomVBoxLayoutWithTriggerSlot_TimerEventDefault(void* ptr, void* event)
 {
-	static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
+	static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::timerEvent(static_cast<QTimerEvent*>(event));
 }
 
 
 
-void* QVBoxLayoutWithTriggerSlot_SpacerItemDefault(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot_SpacerItemDefault(void* ptr)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::spacerItem();
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::spacerItem();
 }
 
-void* QVBoxLayoutWithTriggerSlot_WidgetDefault(void* ptr)
+void* QRoomVBoxLayoutWithTriggerSlot_WidgetDefault(void* ptr)
 {
-	return static_cast<QVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::widget();
+	return static_cast<QRoomVBoxLayoutWithTriggerSlot*>(ptr)->QVBoxLayout::widget();
 }
 
 #include "moc_moc.h"
diff --git a/elements/moc.go b/elements/moc.go
@@ -21,71 +21,71 @@ func cGoUnpackString(s C.struct_Moc_PackedString) string {
 	return C.GoStringN(s.data, C.int(s.len))
 }
 
-type QRoomVBoxLayoutWithTriggerSlot_ITF interface {
+type QVBoxLayoutWithTriggerSlot_ITF interface {
 	std_widgets.QVBoxLayout_ITF
-	QRoomVBoxLayoutWithTriggerSlot_PTR() *QRoomVBoxLayoutWithTriggerSlot
+	QVBoxLayoutWithTriggerSlot_PTR() *QVBoxLayoutWithTriggerSlot
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) QRoomVBoxLayoutWithTriggerSlot_PTR() *QRoomVBoxLayoutWithTriggerSlot {
+func (ptr *QVBoxLayoutWithTriggerSlot) QVBoxLayoutWithTriggerSlot_PTR() *QVBoxLayoutWithTriggerSlot {
 	return ptr
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) Pointer() unsafe.Pointer {
+func (ptr *QVBoxLayoutWithTriggerSlot) Pointer() unsafe.Pointer {
 	if ptr != nil {
 		return ptr.QVBoxLayout_PTR().Pointer()
 	}
 	return nil
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) SetPointer(p unsafe.Pointer) {
+func (ptr *QVBoxLayoutWithTriggerSlot) SetPointer(p unsafe.Pointer) {
 	if ptr != nil {
 		ptr.QVBoxLayout_PTR().SetPointer(p)
 	}
 }
 
-func PointerFromQRoomVBoxLayoutWithTriggerSlot(ptr QRoomVBoxLayoutWithTriggerSlot_ITF) unsafe.Pointer {
+func PointerFromQVBoxLayoutWithTriggerSlot(ptr QVBoxLayoutWithTriggerSlot_ITF) unsafe.Pointer {
 	if ptr != nil {
-		return ptr.QRoomVBoxLayoutWithTriggerSlot_PTR().Pointer()
+		return ptr.QVBoxLayoutWithTriggerSlot_PTR().Pointer()
 	}
 	return nil
 }
 
-func NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr unsafe.Pointer) *QRoomVBoxLayoutWithTriggerSlot {
-	var n *QRoomVBoxLayoutWithTriggerSlot
+func NewQVBoxLayoutWithTriggerSlotFromPointer(ptr unsafe.Pointer) *QVBoxLayoutWithTriggerSlot {
+	var n *QVBoxLayoutWithTriggerSlot
 	if gPtr, ok := qt.Receive(ptr); !ok {
-		n = new(QRoomVBoxLayoutWithTriggerSlot)
+		n = new(QVBoxLayoutWithTriggerSlot)
 		n.SetPointer(ptr)
 	} else {
 		switch deduced := gPtr.(type) {
-		case *QRoomVBoxLayoutWithTriggerSlot:
+		case *QVBoxLayoutWithTriggerSlot:
 			n = deduced
 
 		case *std_widgets.QVBoxLayout:
-			n = &QRoomVBoxLayoutWithTriggerSlot{QVBoxLayout: *deduced}
+			n = &QVBoxLayoutWithTriggerSlot{QVBoxLayout: *deduced}
 
 		default:
-			n = new(QRoomVBoxLayoutWithTriggerSlot)
+			n = new(QVBoxLayoutWithTriggerSlot)
 			n.SetPointer(ptr)
 		}
 	}
 	return n
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_Constructor
-func callbackQRoomVBoxLayoutWithTriggerSlot_Constructor(ptr unsafe.Pointer) {
-	gPtr := NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr)
+//export callbackQVBoxLayoutWithTriggerSlot_Constructor
+func callbackQVBoxLayoutWithTriggerSlot_Constructor(ptr unsafe.Pointer) {
+	gPtr := NewQVBoxLayoutWithTriggerSlotFromPointer(ptr)
 	qt.Register(ptr, gPtr)
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_TriggerMessage
-func callbackQRoomVBoxLayoutWithTriggerSlot_TriggerMessage(ptr unsafe.Pointer, messageBody C.struct_Moc_PackedString, sender C.struct_Moc_PackedString) {
+//export callbackQVBoxLayoutWithTriggerSlot_TriggerMessage
+func callbackQVBoxLayoutWithTriggerSlot_TriggerMessage(ptr unsafe.Pointer, messageBody C.struct_Moc_PackedString, sender C.struct_Moc_PackedString) {
 	if signal := qt.GetSignal(ptr, "TriggerMessage"); signal != nil {
 		signal.(func(string, string))(cGoUnpackString(messageBody), cGoUnpackString(sender))
 	}
 
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) ConnectTriggerMessage(f func(messageBody string, sender string)) {
+func (ptr *QVBoxLayoutWithTriggerSlot) ConnectTriggerMessage(f func(messageBody string, sender string)) {
 	if ptr.Pointer() != nil {
 
 		if signal := qt.LendSignal(ptr.Pointer(), "TriggerMessage"); signal != nil {
@@ -99,14 +99,14 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) ConnectTriggerMessage(f func(messageB
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) DisconnectTriggerMessage() {
+func (ptr *QVBoxLayoutWithTriggerSlot) DisconnectTriggerMessage() {
 	if ptr.Pointer() != nil {
 
 		qt.DisconnectSignal(ptr.Pointer(), "TriggerMessage")
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) TriggerMessage(messageBody string, sender string) {
+func (ptr *QVBoxLayoutWithTriggerSlot) TriggerMessage(messageBody string, sender string) {
 	if ptr.Pointer() != nil {
 		var messageBodyC *C.char
 		if messageBody != "" {
@@ -118,45 +118,45 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) TriggerMessage(messageBody string, se
 			senderC = C.CString(sender)
 			defer C.free(unsafe.Pointer(senderC))
 		}
-		C.QRoomVBoxLayoutWithTriggerSlot_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.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))})
 	}
 }
 
-func QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType() int {
-	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
+func QVBoxLayoutWithTriggerSlot_QRegisterMetaType() int {
+	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) QRegisterMetaType() int {
-	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
+func (ptr *QVBoxLayoutWithTriggerSlot) QRegisterMetaType() int {
+	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
 }
 
-func QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeName string) int {
+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.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
+	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) QRegisterMetaType2(typeName string) int {
+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.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
+	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
 }
 
-func QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType() int {
-	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()))
+func QVBoxLayoutWithTriggerSlot_QmlRegisterType() int {
+	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) QmlRegisterType() int {
-	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()))
+func (ptr *QVBoxLayoutWithTriggerSlot) QmlRegisterType() int {
+	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()))
 }
 
-func QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
+func QVBoxLayoutWithTriggerSlot_QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
 	var uriC *C.char
 	if uri != "" {
 		uriC = C.CString(uri)
@@ -167,10 +167,10 @@ func QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(uri string, versionMajor in
 		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)))
+	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
+func (ptr *QVBoxLayoutWithTriggerSlot) QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
 	var uriC *C.char
 	if uri != "" {
 		uriC = C.CString(uri)
@@ -181,31 +181,31 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) QmlRegisterType2(uri string, versionM
 		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)))
+	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_atList(i int) *std_core.QByteArray {
+func (ptr *QVBoxLayoutWithTriggerSlot) __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))))
+		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 *QRoomVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_setList(i std_core.QByteArray_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_setList(i std_core.QByteArray_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(ptr.Pointer(), std_core.PointerFromQByteArray(i))
+		C.QVBoxLayoutWithTriggerSlot___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 *QVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_newList() unsafe.Pointer {
+	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(ptr.Pointer()))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList2(i int) *std_core.QObject {
+func (ptr *QVBoxLayoutWithTriggerSlot) __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))))
+		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) })
 		}
@@ -214,19 +214,19 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList2(i int) *std_co
 	return nil
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList2(i std_core.QObject_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList2(i std_core.QObject_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot___findChildren_setList2(ptr.Pointer(), std_core.PointerFromQObject(i))
+		C.QVBoxLayoutWithTriggerSlot___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 *QVBoxLayoutWithTriggerSlot) __findChildren_newList2() unsafe.Pointer {
+	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___findChildren_newList2(ptr.Pointer()))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList3(i int) *std_core.QObject {
+func (ptr *QVBoxLayoutWithTriggerSlot) __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))))
+		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) })
 		}
@@ -235,19 +235,19 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList3(i int) *std_co
 	return nil
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList3(i std_core.QObject_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList3(i std_core.QObject_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot___findChildren_setList3(ptr.Pointer(), std_core.PointerFromQObject(i))
+		C.QVBoxLayoutWithTriggerSlot___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 *QVBoxLayoutWithTriggerSlot) __findChildren_newList3() unsafe.Pointer {
+	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___findChildren_newList3(ptr.Pointer()))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList(i int) *std_core.QObject {
+func (ptr *QVBoxLayoutWithTriggerSlot) __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))))
+		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) })
 		}
@@ -256,19 +256,19 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_atList(i int) *std_cor
 	return nil
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList(i std_core.QObject_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList(i std_core.QObject_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot___findChildren_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
+		C.QVBoxLayoutWithTriggerSlot___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 *QVBoxLayoutWithTriggerSlot) __findChildren_newList() unsafe.Pointer {
+	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___findChildren_newList(ptr.Pointer()))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __children_atList(i int) *std_core.QObject {
+func (ptr *QVBoxLayoutWithTriggerSlot) __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))))
+		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) })
 		}
@@ -277,263 +277,263 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) __children_atList(i int) *std_core.QO
 	return nil
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) __children_setList(i std_core.QObject_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) __children_setList(i std_core.QObject_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot___children_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
+		C.QVBoxLayoutWithTriggerSlot___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 (ptr *QVBoxLayoutWithTriggerSlot) __children_newList() unsafe.Pointer {
+	return unsafe.Pointer(C.QVBoxLayoutWithTriggerSlot___children_newList(ptr.Pointer()))
 }
 
-func NewQRoomVBoxLayoutWithTriggerSlot() *QRoomVBoxLayoutWithTriggerSlot {
-	var tmpValue = NewQRoomVBoxLayoutWithTriggerSlotFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot())
+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 NewQRoomVBoxLayoutWithTriggerSlot2(parent std_widgets.QWidget_ITF) *QRoomVBoxLayoutWithTriggerSlot {
-	var tmpValue = NewQRoomVBoxLayoutWithTriggerSlotFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_NewQRoomVBoxLayoutWithTriggerSlot2(std_widgets.PointerFromQWidget(parent)))
+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 *QRoomVBoxLayoutWithTriggerSlot) DestroyQRoomVBoxLayoutWithTriggerSlot() {
+func (ptr *QVBoxLayoutWithTriggerSlot) DestroyQVBoxLayoutWithTriggerSlot() {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_DestroyQRoomVBoxLayoutWithTriggerSlot(ptr.Pointer())
+		C.QVBoxLayoutWithTriggerSlot_DestroyQVBoxLayoutWithTriggerSlot(ptr.Pointer())
 		ptr.SetPointer(nil)
 		runtime.SetFinalizer(ptr, nil)
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_TakeAt
-func callbackQRoomVBoxLayoutWithTriggerSlot_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).TakeAtDefault(int(int32(index))))
+	return std_widgets.PointerFromQLayoutItem(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).TakeAtDefault(int(int32(index))))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) TakeAtDefault(index int) *std_widgets.QLayoutItem {
+func (ptr *QVBoxLayoutWithTriggerSlot) TakeAtDefault(index int) *std_widgets.QLayoutItem {
 	if ptr.Pointer() != nil {
-		return std_widgets.NewQLayoutItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
+		return std_widgets.NewQLayoutItemFromPointer(C.QVBoxLayoutWithTriggerSlot_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
 	}
 	return nil
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_AddItem
-func callbackQRoomVBoxLayoutWithTriggerSlot_AddItem(ptr unsafe.Pointer, item unsafe.Pointer) {
+//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 {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).AddItemDefault(std_widgets.NewQLayoutItemFromPointer(item))
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).AddItemDefault(std_widgets.NewQLayoutItemFromPointer(item))
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) AddItemDefault(item std_widgets.QLayoutItem_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) AddItemDefault(item std_widgets.QLayoutItem_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_AddItemDefault(ptr.Pointer(), std_widgets.PointerFromQLayoutItem(item))
+		C.QVBoxLayoutWithTriggerSlot_AddItemDefault(ptr.Pointer(), std_widgets.PointerFromQLayoutItem(item))
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_Invalidate
-func callbackQRoomVBoxLayoutWithTriggerSlot_Invalidate(ptr unsafe.Pointer) {
+//export callbackQVBoxLayoutWithTriggerSlot_Invalidate
+func callbackQVBoxLayoutWithTriggerSlot_Invalidate(ptr unsafe.Pointer) {
 	if signal := qt.GetSignal(ptr, "invalidate"); signal != nil {
 		signal.(func())()
 	} else {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).InvalidateDefault()
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).InvalidateDefault()
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) InvalidateDefault() {
+func (ptr *QVBoxLayoutWithTriggerSlot) InvalidateDefault() {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_InvalidateDefault(ptr.Pointer())
+		C.QVBoxLayoutWithTriggerSlot_InvalidateDefault(ptr.Pointer())
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_SetGeometry
-func callbackQRoomVBoxLayoutWithTriggerSlot_SetGeometry(ptr unsafe.Pointer, r unsafe.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 {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SetGeometryDefault(std_core.NewQRectFromPointer(r))
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SetGeometryDefault(std_core.NewQRectFromPointer(r))
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) SetGeometryDefault(r std_core.QRect_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) SetGeometryDefault(r std_core.QRect_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_SetGeometryDefault(ptr.Pointer(), std_core.PointerFromQRect(r))
+		C.QVBoxLayoutWithTriggerSlot_SetGeometryDefault(ptr.Pointer(), std_core.PointerFromQRect(r))
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_ItemAt
-func callbackQRoomVBoxLayoutWithTriggerSlot_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ItemAtDefault(int(int32(index))))
+	return std_widgets.PointerFromQLayoutItem(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ItemAtDefault(int(int32(index))))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) ItemAtDefault(index int) *std_widgets.QLayoutItem {
+func (ptr *QVBoxLayoutWithTriggerSlot) ItemAtDefault(index int) *std_widgets.QLayoutItem {
 	if ptr.Pointer() != nil {
-		return std_widgets.NewQLayoutItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
+		return std_widgets.NewQLayoutItemFromPointer(C.QVBoxLayoutWithTriggerSlot_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
 	}
 	return nil
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_MaximumSize
-func callbackQRoomVBoxLayoutWithTriggerSlot_MaximumSize(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MaximumSizeDefault())
+	return std_core.PointerFromQSize(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MaximumSizeDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) MaximumSizeDefault() *std_core.QSize {
+func (ptr *QVBoxLayoutWithTriggerSlot) MaximumSizeDefault() *std_core.QSize {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_MaximumSizeDefault(ptr.Pointer()))
+		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_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 {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumSizeDefault())
+	return std_core.PointerFromQSize(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumSizeDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) MinimumSizeDefault() *std_core.QSize {
+func (ptr *QVBoxLayoutWithTriggerSlot) MinimumSizeDefault() *std_core.QSize {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_MinimumSizeDefault(ptr.Pointer()))
+		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_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 {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SizeHintDefault())
+	return std_core.PointerFromQSize(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SizeHintDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) SizeHintDefault() *std_core.QSize {
+func (ptr *QVBoxLayoutWithTriggerSlot) SizeHintDefault() *std_core.QSize {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_SizeHintDefault(ptr.Pointer()))
+		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_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 {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ExpandingDirectionsDefault())
+	return C.longlong(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ExpandingDirectionsDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) ExpandingDirectionsDefault() std_core.Qt__Orientation {
+func (ptr *QVBoxLayoutWithTriggerSlot) ExpandingDirectionsDefault() std_core.Qt__Orientation {
 	if ptr.Pointer() != nil {
-		return std_core.Qt__Orientation(C.QRoomVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(ptr.Pointer()))
+		return std_core.Qt__Orientation(C.QVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(ptr.Pointer()))
 	}
 	return 0
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_HasHeightForWidth
-func callbackQRoomVBoxLayoutWithTriggerSlot_HasHeightForWidth(ptr unsafe.Pointer) C.char {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).HasHeightForWidthDefault())))
+	return C.char(int8(qt.GoBoolToInt(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).HasHeightForWidthDefault())))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) HasHeightForWidthDefault() bool {
+func (ptr *QVBoxLayoutWithTriggerSlot) HasHeightForWidthDefault() bool {
 	if ptr.Pointer() != nil {
-		return C.QRoomVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(ptr.Pointer()) != 0
+		return C.QVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(ptr.Pointer()) != 0
 	}
 	return false
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_Count
-func callbackQRoomVBoxLayoutWithTriggerSlot_Count(ptr unsafe.Pointer) C.int {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).CountDefault()))
+	return C.int(int32(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).CountDefault()))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) CountDefault() int {
+func (ptr *QVBoxLayoutWithTriggerSlot) CountDefault() int {
 	if ptr.Pointer() != nil {
-		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_CountDefault(ptr.Pointer())))
+		return int(int32(C.QVBoxLayoutWithTriggerSlot_CountDefault(ptr.Pointer())))
 	}
 	return 0
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_HeightForWidth
-func callbackQRoomVBoxLayoutWithTriggerSlot_HeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
+	return C.int(int32(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) HeightForWidthDefault(w int) int {
+func (ptr *QVBoxLayoutWithTriggerSlot) HeightForWidthDefault(w int) int {
 	if ptr.Pointer() != nil {
-		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
+		return int(int32(C.QVBoxLayoutWithTriggerSlot_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
 	}
 	return 0
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidth
-func callbackQRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumHeightForWidthDefault(int(int32(w)))))
+	return C.int(int32(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumHeightForWidthDefault(int(int32(w)))))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) MinimumHeightForWidthDefault(w int) int {
+func (ptr *QVBoxLayoutWithTriggerSlot) MinimumHeightForWidthDefault(w int) int {
 	if ptr.Pointer() != nil {
-		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
+		return int(int32(C.QVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
 	}
 	return 0
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_Layout
-func callbackQRoomVBoxLayoutWithTriggerSlot_Layout(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).LayoutDefault())
+	return std_widgets.PointerFromQLayout(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).LayoutDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) LayoutDefault() *std_widgets.QLayout {
+func (ptr *QVBoxLayoutWithTriggerSlot) LayoutDefault() *std_widgets.QLayout {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_widgets.NewQLayoutFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_LayoutDefault(ptr.Pointer()))
+		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) })
 		}
@@ -542,240 +542,240 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) LayoutDefault() *std_widgets.QLayout 
 	return nil
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_ChildEvent
-func callbackQRoomVBoxLayoutWithTriggerSlot_ChildEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
+//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 {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ChildEventDefault(std_core.NewQChildEventFromPointer(e))
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ChildEventDefault(std_core.NewQChildEventFromPointer(e))
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) ChildEventDefault(e std_core.QChildEvent_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) ChildEventDefault(e std_core.QChildEvent_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_ChildEventDefault(ptr.Pointer(), std_core.PointerFromQChildEvent(e))
+		C.QVBoxLayoutWithTriggerSlot_ChildEventDefault(ptr.Pointer(), std_core.PointerFromQChildEvent(e))
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_Geometry
-func callbackQRoomVBoxLayoutWithTriggerSlot_Geometry(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).GeometryDefault())
+	return std_core.PointerFromQRect(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).GeometryDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) GeometryDefault() *std_core.QRect {
+func (ptr *QVBoxLayoutWithTriggerSlot) GeometryDefault() *std_core.QRect {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_core.NewQRectFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_GeometryDefault(ptr.Pointer()))
+		var tmpValue = std_core.NewQRectFromPointer(C.QVBoxLayoutWithTriggerSlot_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 {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ControlTypesDefault())
+	return C.longlong(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ControlTypesDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) ControlTypesDefault() std_widgets.QSizePolicy__ControlType {
+func (ptr *QVBoxLayoutWithTriggerSlot) ControlTypesDefault() std_widgets.QSizePolicy__ControlType {
 	if ptr.Pointer() != nil {
-		return std_widgets.QSizePolicy__ControlType(C.QRoomVBoxLayoutWithTriggerSlot_ControlTypesDefault(ptr.Pointer()))
+		return std_widgets.QSizePolicy__ControlType(C.QVBoxLayoutWithTriggerSlot_ControlTypesDefault(ptr.Pointer()))
 	}
 	return 0
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_IsEmpty
-func callbackQRoomVBoxLayoutWithTriggerSlot_IsEmpty(ptr unsafe.Pointer) C.char {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).IsEmptyDefault())))
+	return C.char(int8(qt.GoBoolToInt(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).IsEmptyDefault())))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) IsEmptyDefault() bool {
+func (ptr *QVBoxLayoutWithTriggerSlot) IsEmptyDefault() bool {
 	if ptr.Pointer() != nil {
-		return C.QRoomVBoxLayoutWithTriggerSlot_IsEmptyDefault(ptr.Pointer()) != 0
+		return C.QVBoxLayoutWithTriggerSlot_IsEmptyDefault(ptr.Pointer()) != 0
 	}
 	return false
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_IndexOf
-func callbackQRoomVBoxLayoutWithTriggerSlot_IndexOf(ptr unsafe.Pointer, widget unsafe.Pointer) C.int {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).IndexOfDefault(std_widgets.NewQWidgetFromPointer(widget))))
+	return C.int(int32(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).IndexOfDefault(std_widgets.NewQWidgetFromPointer(widget))))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) IndexOfDefault(widget std_widgets.QWidget_ITF) int {
+func (ptr *QVBoxLayoutWithTriggerSlot) IndexOfDefault(widget std_widgets.QWidget_ITF) int {
 	if ptr.Pointer() != nil {
-		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_IndexOfDefault(ptr.Pointer(), std_widgets.PointerFromQWidget(widget))))
+		return int(int32(C.QVBoxLayoutWithTriggerSlot_IndexOfDefault(ptr.Pointer(), std_widgets.PointerFromQWidget(widget))))
 	}
 	return 0
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_Event
-func callbackQRoomVBoxLayoutWithTriggerSlot_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).EventDefault(std_core.NewQEventFromPointer(e)))))
+	return C.char(int8(qt.GoBoolToInt(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).EventDefault(std_core.NewQEventFromPointer(e)))))
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) EventDefault(e std_core.QEvent_ITF) bool {
+func (ptr *QVBoxLayoutWithTriggerSlot) EventDefault(e std_core.QEvent_ITF) bool {
 	if ptr.Pointer() != nil {
-		return C.QRoomVBoxLayoutWithTriggerSlot_EventDefault(ptr.Pointer(), std_core.PointerFromQEvent(e)) != 0
+		return C.QVBoxLayoutWithTriggerSlot_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 {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).EventFilterDefault(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 *QRoomVBoxLayoutWithTriggerSlot) EventFilterDefault(watched std_core.QObject_ITF, event std_core.QEvent_ITF) bool {
+func (ptr *QVBoxLayoutWithTriggerSlot) 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 C.QVBoxLayoutWithTriggerSlot_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) {
+//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 {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ConnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ConnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) ConnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) ConnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
+		C.QVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_CustomEvent
-func callbackQRoomVBoxLayoutWithTriggerSlot_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
+//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 {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).CustomEventDefault(std_core.NewQEventFromPointer(event))
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).CustomEventDefault(std_core.NewQEventFromPointer(event))
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) CustomEventDefault(event std_core.QEvent_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) CustomEventDefault(event std_core.QEvent_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_CustomEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
+		C.QVBoxLayoutWithTriggerSlot_CustomEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_DeleteLater
-func callbackQRoomVBoxLayoutWithTriggerSlot_DeleteLater(ptr unsafe.Pointer) {
+//export callbackQVBoxLayoutWithTriggerSlot_DeleteLater
+func callbackQVBoxLayoutWithTriggerSlot_DeleteLater(ptr unsafe.Pointer) {
 	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
 		signal.(func())()
 	} else {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).DeleteLaterDefault()
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).DeleteLaterDefault()
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) DeleteLaterDefault() {
+func (ptr *QVBoxLayoutWithTriggerSlot) DeleteLaterDefault() {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_DeleteLaterDefault(ptr.Pointer())
+		C.QVBoxLayoutWithTriggerSlot_DeleteLaterDefault(ptr.Pointer())
 		ptr.SetPointer(nil)
 		runtime.SetFinalizer(ptr, nil)
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_Destroyed
-func callbackQRoomVBoxLayoutWithTriggerSlot_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
+//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 callbackQRoomVBoxLayoutWithTriggerSlot_DisconnectNotify
-func callbackQRoomVBoxLayoutWithTriggerSlot_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
+//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 {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).DisconnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).DisconnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) DisconnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) DisconnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
+		C.QVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_ObjectNameChanged
-func callbackQRoomVBoxLayoutWithTriggerSlot_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_Moc_PackedString) {
+//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 callbackQRoomVBoxLayoutWithTriggerSlot_TimerEvent
-func callbackQRoomVBoxLayoutWithTriggerSlot_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
+//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 {
-		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).TimerEventDefault(std_core.NewQTimerEventFromPointer(event))
+		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).TimerEventDefault(std_core.NewQTimerEventFromPointer(event))
 	}
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) TimerEventDefault(event std_core.QTimerEvent_ITF) {
+func (ptr *QVBoxLayoutWithTriggerSlot) TimerEventDefault(event std_core.QTimerEvent_ITF) {
 	if ptr.Pointer() != nil {
-		C.QRoomVBoxLayoutWithTriggerSlot_TimerEventDefault(ptr.Pointer(), std_core.PointerFromQTimerEvent(event))
+		C.QVBoxLayoutWithTriggerSlot_TimerEventDefault(ptr.Pointer(), std_core.PointerFromQTimerEvent(event))
 	}
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_SpacerItem
-func callbackQRoomVBoxLayoutWithTriggerSlot_SpacerItem(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SpacerItemDefault())
+	return std_widgets.PointerFromQSpacerItem(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SpacerItemDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) SpacerItemDefault() *std_widgets.QSpacerItem {
+func (ptr *QVBoxLayoutWithTriggerSlot) SpacerItemDefault() *std_widgets.QSpacerItem {
 	if ptr.Pointer() != nil {
-		return std_widgets.NewQSpacerItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_SpacerItemDefault(ptr.Pointer()))
+		return std_widgets.NewQSpacerItemFromPointer(C.QVBoxLayoutWithTriggerSlot_SpacerItemDefault(ptr.Pointer()))
 	}
 	return nil
 }
 
-//export callbackQRoomVBoxLayoutWithTriggerSlot_Widget
-func callbackQRoomVBoxLayoutWithTriggerSlot_Widget(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).WidgetDefault())
+	return std_widgets.PointerFromQWidget(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).WidgetDefault())
 }
 
-func (ptr *QRoomVBoxLayoutWithTriggerSlot) WidgetDefault() *std_widgets.QWidget {
+func (ptr *QVBoxLayoutWithTriggerSlot) WidgetDefault() *std_widgets.QWidget {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_widgets.NewQWidgetFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_WidgetDefault(ptr.Pointer()))
+		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) })
 		}
@@ -784,71 +784,71 @@ func (ptr *QRoomVBoxLayoutWithTriggerSlot) WidgetDefault() *std_widgets.QWidget 
 	return nil
 }
 
-type QVBoxLayoutWithTriggerSlot_ITF interface {
+type QRoomVBoxLayoutWithTriggerSlot_ITF interface {
 	std_widgets.QVBoxLayout_ITF
-	QVBoxLayoutWithTriggerSlot_PTR() *QVBoxLayoutWithTriggerSlot
+	QRoomVBoxLayoutWithTriggerSlot_PTR() *QRoomVBoxLayoutWithTriggerSlot
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) QVBoxLayoutWithTriggerSlot_PTR() *QVBoxLayoutWithTriggerSlot {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) QRoomVBoxLayoutWithTriggerSlot_PTR() *QRoomVBoxLayoutWithTriggerSlot {
 	return ptr
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) Pointer() unsafe.Pointer {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) Pointer() unsafe.Pointer {
 	if ptr != nil {
 		return ptr.QVBoxLayout_PTR().Pointer()
 	}
 	return nil
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) SetPointer(p unsafe.Pointer) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) SetPointer(p unsafe.Pointer) {
 	if ptr != nil {
 		ptr.QVBoxLayout_PTR().SetPointer(p)
 	}
 }
 
-func PointerFromQVBoxLayoutWithTriggerSlot(ptr QVBoxLayoutWithTriggerSlot_ITF) unsafe.Pointer {
+func PointerFromQRoomVBoxLayoutWithTriggerSlot(ptr QRoomVBoxLayoutWithTriggerSlot_ITF) unsafe.Pointer {
 	if ptr != nil {
-		return ptr.QVBoxLayoutWithTriggerSlot_PTR().Pointer()
+		return ptr.QRoomVBoxLayoutWithTriggerSlot_PTR().Pointer()
 	}
 	return nil
 }
 
-func NewQVBoxLayoutWithTriggerSlotFromPointer(ptr unsafe.Pointer) *QVBoxLayoutWithTriggerSlot {
-	var n *QVBoxLayoutWithTriggerSlot
+func NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr unsafe.Pointer) *QRoomVBoxLayoutWithTriggerSlot {
+	var n *QRoomVBoxLayoutWithTriggerSlot
 	if gPtr, ok := qt.Receive(ptr); !ok {
-		n = new(QVBoxLayoutWithTriggerSlot)
+		n = new(QRoomVBoxLayoutWithTriggerSlot)
 		n.SetPointer(ptr)
 	} else {
 		switch deduced := gPtr.(type) {
-		case *QVBoxLayoutWithTriggerSlot:
+		case *QRoomVBoxLayoutWithTriggerSlot:
 			n = deduced
 
 		case *std_widgets.QVBoxLayout:
-			n = &QVBoxLayoutWithTriggerSlot{QVBoxLayout: *deduced}
+			n = &QRoomVBoxLayoutWithTriggerSlot{QVBoxLayout: *deduced}
 
 		default:
-			n = new(QVBoxLayoutWithTriggerSlot)
+			n = new(QRoomVBoxLayoutWithTriggerSlot)
 			n.SetPointer(ptr)
 		}
 	}
 	return n
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_Constructor
-func callbackQVBoxLayoutWithTriggerSlot_Constructor(ptr unsafe.Pointer) {
-	gPtr := NewQVBoxLayoutWithTriggerSlotFromPointer(ptr)
+//export callbackQRoomVBoxLayoutWithTriggerSlot_Constructor
+func callbackQRoomVBoxLayoutWithTriggerSlot_Constructor(ptr unsafe.Pointer) {
+	gPtr := NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr)
 	qt.Register(ptr, gPtr)
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_TriggerMessage
-func callbackQVBoxLayoutWithTriggerSlot_TriggerMessage(ptr unsafe.Pointer, messageBody C.struct_Moc_PackedString, sender C.struct_Moc_PackedString) {
+//export callbackQRoomVBoxLayoutWithTriggerSlot_TriggerMessage
+func callbackQRoomVBoxLayoutWithTriggerSlot_TriggerMessage(ptr unsafe.Pointer, messageBody C.struct_Moc_PackedString, sender C.struct_Moc_PackedString) {
 	if signal := qt.GetSignal(ptr, "TriggerMessage"); signal != nil {
 		signal.(func(string, string))(cGoUnpackString(messageBody), cGoUnpackString(sender))
 	}
 
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) ConnectTriggerMessage(f func(messageBody string, sender string)) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) ConnectTriggerMessage(f func(messageBody string, sender string)) {
 	if ptr.Pointer() != nil {
 
 		if signal := qt.LendSignal(ptr.Pointer(), "TriggerMessage"); signal != nil {
@@ -862,14 +862,14 @@ func (ptr *QVBoxLayoutWithTriggerSlot) ConnectTriggerMessage(f func(messageBody 
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) DisconnectTriggerMessage() {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) DisconnectTriggerMessage() {
 	if ptr.Pointer() != nil {
 
 		qt.DisconnectSignal(ptr.Pointer(), "TriggerMessage")
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) TriggerMessage(messageBody string, sender string) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) TriggerMessage(messageBody string, sender string) {
 	if ptr.Pointer() != nil {
 		var messageBodyC *C.char
 		if messageBody != "" {
@@ -881,45 +881,45 @@ func (ptr *QVBoxLayoutWithTriggerSlot) TriggerMessage(messageBody string, 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.QRoomVBoxLayoutWithTriggerSlot_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))})
 	}
 }
 
-func QVBoxLayoutWithTriggerSlot_QRegisterMetaType() int {
-	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
+func QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType() int {
+	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) QRegisterMetaType() int {
-	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) QRegisterMetaType() int {
+	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType()))
 }
 
-func QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeName string) int {
+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.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
+	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) QRegisterMetaType2(typeName string) int {
+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.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
+	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QRegisterMetaType2(typeNameC)))
 }
 
-func QVBoxLayoutWithTriggerSlot_QmlRegisterType() int {
-	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()))
+func QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType() int {
+	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) QmlRegisterType() int {
-	return int(int32(C.QVBoxLayoutWithTriggerSlot_QVBoxLayoutWithTriggerSlot_QmlRegisterType()))
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) QmlRegisterType() int {
+	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType()))
 }
 
-func QVBoxLayoutWithTriggerSlot_QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
+func QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
 	var uriC *C.char
 	if uri != "" {
 		uriC = C.CString(uri)
@@ -930,10 +930,10 @@ func QVBoxLayoutWithTriggerSlot_QmlRegisterType2(uri string, versionMajor int, v
 		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)))
+	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) QmlRegisterType2(uri string, versionMajor int, versionMinor int, qmlName string) int {
 	var uriC *C.char
 	if uri != "" {
 		uriC = C.CString(uri)
@@ -944,31 +944,31 @@ func (ptr *QVBoxLayoutWithTriggerSlot) QmlRegisterType2(uri string, versionMajor
 		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)))
+	return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_QRoomVBoxLayoutWithTriggerSlot_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_atList(i int) *std_core.QByteArray {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __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))))
+		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 *QVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_setList(i std_core.QByteArray_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_setList(i std_core.QByteArray_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot___dynamicPropertyNames_setList(ptr.Pointer(), std_core.PointerFromQByteArray(i))
+		C.QRoomVBoxLayoutWithTriggerSlot___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 *QRoomVBoxLayoutWithTriggerSlot) __dynamicPropertyNames_newList() unsafe.Pointer {
+	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___dynamicPropertyNames_newList(ptr.Pointer()))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList2(i int) *std_core.QObject {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __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))))
+		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) })
 		}
@@ -977,19 +977,19 @@ func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList2(i int) *std_core.Q
 	return nil
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList2(i std_core.QObject_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList2(i std_core.QObject_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot___findChildren_setList2(ptr.Pointer(), std_core.PointerFromQObject(i))
+		C.QRoomVBoxLayoutWithTriggerSlot___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 *QRoomVBoxLayoutWithTriggerSlot) __findChildren_newList2() unsafe.Pointer {
+	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_newList2(ptr.Pointer()))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList3(i int) *std_core.QObject {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __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))))
+		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) })
 		}
@@ -998,19 +998,19 @@ func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList3(i int) *std_core.Q
 	return nil
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList3(i std_core.QObject_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList3(i std_core.QObject_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot___findChildren_setList3(ptr.Pointer(), std_core.PointerFromQObject(i))
+		C.QRoomVBoxLayoutWithTriggerSlot___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 *QRoomVBoxLayoutWithTriggerSlot) __findChildren_newList3() unsafe.Pointer {
+	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_newList3(ptr.Pointer()))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList(i int) *std_core.QObject {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __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))))
+		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) })
 		}
@@ -1019,19 +1019,19 @@ func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_atList(i int) *std_core.QO
 	return nil
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __findChildren_setList(i std_core.QObject_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __findChildren_setList(i std_core.QObject_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot___findChildren_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
+		C.QRoomVBoxLayoutWithTriggerSlot___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 *QRoomVBoxLayoutWithTriggerSlot) __findChildren_newList() unsafe.Pointer {
+	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___findChildren_newList(ptr.Pointer()))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __children_atList(i int) *std_core.QObject {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __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))))
+		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) })
 		}
@@ -1040,263 +1040,263 @@ func (ptr *QVBoxLayoutWithTriggerSlot) __children_atList(i int) *std_core.QObjec
 	return nil
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) __children_setList(i std_core.QObject_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) __children_setList(i std_core.QObject_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot___children_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
+		C.QRoomVBoxLayoutWithTriggerSlot___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 (ptr *QRoomVBoxLayoutWithTriggerSlot) __children_newList() unsafe.Pointer {
+	return unsafe.Pointer(C.QRoomVBoxLayoutWithTriggerSlot___children_newList(ptr.Pointer()))
 }
 
-func NewQVBoxLayoutWithTriggerSlot() *QVBoxLayoutWithTriggerSlot {
-	var tmpValue = NewQVBoxLayoutWithTriggerSlotFromPointer(C.QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot())
+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 NewQVBoxLayoutWithTriggerSlot2(parent std_widgets.QWidget_ITF) *QVBoxLayoutWithTriggerSlot {
-	var tmpValue = NewQVBoxLayoutWithTriggerSlotFromPointer(C.QVBoxLayoutWithTriggerSlot_NewQVBoxLayoutWithTriggerSlot2(std_widgets.PointerFromQWidget(parent)))
+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 *QVBoxLayoutWithTriggerSlot) DestroyQVBoxLayoutWithTriggerSlot() {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) DestroyQRoomVBoxLayoutWithTriggerSlot() {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_DestroyQVBoxLayoutWithTriggerSlot(ptr.Pointer())
+		C.QRoomVBoxLayoutWithTriggerSlot_DestroyQRoomVBoxLayoutWithTriggerSlot(ptr.Pointer())
 		ptr.SetPointer(nil)
 		runtime.SetFinalizer(ptr, nil)
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_TakeAt
-func callbackQVBoxLayoutWithTriggerSlot_TakeAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).TakeAtDefault(int(int32(index))))
+	return std_widgets.PointerFromQLayoutItem(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).TakeAtDefault(int(int32(index))))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) TakeAtDefault(index int) *std_widgets.QLayoutItem {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) TakeAtDefault(index int) *std_widgets.QLayoutItem {
 	if ptr.Pointer() != nil {
-		return std_widgets.NewQLayoutItemFromPointer(C.QVBoxLayoutWithTriggerSlot_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
+		return std_widgets.NewQLayoutItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_TakeAtDefault(ptr.Pointer(), C.int(int32(index))))
 	}
 	return nil
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_AddItem
-func callbackQVBoxLayoutWithTriggerSlot_AddItem(ptr unsafe.Pointer, item unsafe.Pointer) {
+//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 {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).AddItemDefault(std_widgets.NewQLayoutItemFromPointer(item))
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).AddItemDefault(std_widgets.NewQLayoutItemFromPointer(item))
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) AddItemDefault(item std_widgets.QLayoutItem_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) AddItemDefault(item std_widgets.QLayoutItem_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_AddItemDefault(ptr.Pointer(), std_widgets.PointerFromQLayoutItem(item))
+		C.QRoomVBoxLayoutWithTriggerSlot_AddItemDefault(ptr.Pointer(), std_widgets.PointerFromQLayoutItem(item))
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_Invalidate
-func callbackQVBoxLayoutWithTriggerSlot_Invalidate(ptr unsafe.Pointer) {
+//export callbackQRoomVBoxLayoutWithTriggerSlot_Invalidate
+func callbackQRoomVBoxLayoutWithTriggerSlot_Invalidate(ptr unsafe.Pointer) {
 	if signal := qt.GetSignal(ptr, "invalidate"); signal != nil {
 		signal.(func())()
 	} else {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).InvalidateDefault()
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).InvalidateDefault()
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) InvalidateDefault() {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) InvalidateDefault() {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_InvalidateDefault(ptr.Pointer())
+		C.QRoomVBoxLayoutWithTriggerSlot_InvalidateDefault(ptr.Pointer())
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_SetGeometry
-func callbackQVBoxLayoutWithTriggerSlot_SetGeometry(ptr unsafe.Pointer, r unsafe.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 {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SetGeometryDefault(std_core.NewQRectFromPointer(r))
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SetGeometryDefault(std_core.NewQRectFromPointer(r))
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) SetGeometryDefault(r std_core.QRect_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) SetGeometryDefault(r std_core.QRect_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_SetGeometryDefault(ptr.Pointer(), std_core.PointerFromQRect(r))
+		C.QRoomVBoxLayoutWithTriggerSlot_SetGeometryDefault(ptr.Pointer(), std_core.PointerFromQRect(r))
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_ItemAt
-func callbackQVBoxLayoutWithTriggerSlot_ItemAt(ptr unsafe.Pointer, index C.int) unsafe.Pointer {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ItemAtDefault(int(int32(index))))
+	return std_widgets.PointerFromQLayoutItem(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ItemAtDefault(int(int32(index))))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) ItemAtDefault(index int) *std_widgets.QLayoutItem {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) ItemAtDefault(index int) *std_widgets.QLayoutItem {
 	if ptr.Pointer() != nil {
-		return std_widgets.NewQLayoutItemFromPointer(C.QVBoxLayoutWithTriggerSlot_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
+		return std_widgets.NewQLayoutItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_ItemAtDefault(ptr.Pointer(), C.int(int32(index))))
 	}
 	return nil
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_MaximumSize
-func callbackQVBoxLayoutWithTriggerSlot_MaximumSize(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MaximumSizeDefault())
+	return std_core.PointerFromQSize(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MaximumSizeDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) MaximumSizeDefault() *std_core.QSize {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) MaximumSizeDefault() *std_core.QSize {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_MaximumSizeDefault(ptr.Pointer()))
+		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_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 {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumSizeDefault())
+	return std_core.PointerFromQSize(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumSizeDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) MinimumSizeDefault() *std_core.QSize {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) MinimumSizeDefault() *std_core.QSize {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_MinimumSizeDefault(ptr.Pointer()))
+		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_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 {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SizeHintDefault())
+	return std_core.PointerFromQSize(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SizeHintDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) SizeHintDefault() *std_core.QSize {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) SizeHintDefault() *std_core.QSize {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_core.NewQSizeFromPointer(C.QVBoxLayoutWithTriggerSlot_SizeHintDefault(ptr.Pointer()))
+		var tmpValue = std_core.NewQSizeFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_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 {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ExpandingDirectionsDefault())
+	return C.longlong(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ExpandingDirectionsDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) ExpandingDirectionsDefault() std_core.Qt__Orientation {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) ExpandingDirectionsDefault() std_core.Qt__Orientation {
 	if ptr.Pointer() != nil {
-		return std_core.Qt__Orientation(C.QVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(ptr.Pointer()))
+		return std_core.Qt__Orientation(C.QRoomVBoxLayoutWithTriggerSlot_ExpandingDirectionsDefault(ptr.Pointer()))
 	}
 	return 0
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_HasHeightForWidth
-func callbackQVBoxLayoutWithTriggerSlot_HasHeightForWidth(ptr unsafe.Pointer) C.char {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).HasHeightForWidthDefault())))
+	return C.char(int8(qt.GoBoolToInt(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).HasHeightForWidthDefault())))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) HasHeightForWidthDefault() bool {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) HasHeightForWidthDefault() bool {
 	if ptr.Pointer() != nil {
-		return C.QVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(ptr.Pointer()) != 0
+		return C.QRoomVBoxLayoutWithTriggerSlot_HasHeightForWidthDefault(ptr.Pointer()) != 0
 	}
 	return false
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_Count
-func callbackQVBoxLayoutWithTriggerSlot_Count(ptr unsafe.Pointer) C.int {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).CountDefault()))
+	return C.int(int32(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).CountDefault()))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) CountDefault() int {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) CountDefault() int {
 	if ptr.Pointer() != nil {
-		return int(int32(C.QVBoxLayoutWithTriggerSlot_CountDefault(ptr.Pointer())))
+		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_CountDefault(ptr.Pointer())))
 	}
 	return 0
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_HeightForWidth
-func callbackQVBoxLayoutWithTriggerSlot_HeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
+	return C.int(int32(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) HeightForWidthDefault(w int) int {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) HeightForWidthDefault(w int) int {
 	if ptr.Pointer() != nil {
-		return int(int32(C.QVBoxLayoutWithTriggerSlot_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
+		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
 	}
 	return 0
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_MinimumHeightForWidth
-func callbackQVBoxLayoutWithTriggerSlot_MinimumHeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumHeightForWidthDefault(int(int32(w)))))
+	return C.int(int32(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).MinimumHeightForWidthDefault(int(int32(w)))))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) MinimumHeightForWidthDefault(w int) int {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) MinimumHeightForWidthDefault(w int) int {
 	if ptr.Pointer() != nil {
-		return int(int32(C.QVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
+		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_MinimumHeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
 	}
 	return 0
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_Layout
-func callbackQVBoxLayoutWithTriggerSlot_Layout(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).LayoutDefault())
+	return std_widgets.PointerFromQLayout(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).LayoutDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) LayoutDefault() *std_widgets.QLayout {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) LayoutDefault() *std_widgets.QLayout {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_widgets.NewQLayoutFromPointer(C.QVBoxLayoutWithTriggerSlot_LayoutDefault(ptr.Pointer()))
+		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) })
 		}
@@ -1305,240 +1305,240 @@ func (ptr *QVBoxLayoutWithTriggerSlot) LayoutDefault() *std_widgets.QLayout {
 	return nil
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_ChildEvent
-func callbackQVBoxLayoutWithTriggerSlot_ChildEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
+//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 {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ChildEventDefault(std_core.NewQChildEventFromPointer(e))
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ChildEventDefault(std_core.NewQChildEventFromPointer(e))
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) ChildEventDefault(e std_core.QChildEvent_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) ChildEventDefault(e std_core.QChildEvent_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_ChildEventDefault(ptr.Pointer(), std_core.PointerFromQChildEvent(e))
+		C.QRoomVBoxLayoutWithTriggerSlot_ChildEventDefault(ptr.Pointer(), std_core.PointerFromQChildEvent(e))
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_Geometry
-func callbackQVBoxLayoutWithTriggerSlot_Geometry(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).GeometryDefault())
+	return std_core.PointerFromQRect(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).GeometryDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) GeometryDefault() *std_core.QRect {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) GeometryDefault() *std_core.QRect {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_core.NewQRectFromPointer(C.QVBoxLayoutWithTriggerSlot_GeometryDefault(ptr.Pointer()))
+		var tmpValue = std_core.NewQRectFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_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 {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ControlTypesDefault())
+	return C.longlong(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ControlTypesDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) ControlTypesDefault() std_widgets.QSizePolicy__ControlType {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) ControlTypesDefault() std_widgets.QSizePolicy__ControlType {
 	if ptr.Pointer() != nil {
-		return std_widgets.QSizePolicy__ControlType(C.QVBoxLayoutWithTriggerSlot_ControlTypesDefault(ptr.Pointer()))
+		return std_widgets.QSizePolicy__ControlType(C.QRoomVBoxLayoutWithTriggerSlot_ControlTypesDefault(ptr.Pointer()))
 	}
 	return 0
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_IsEmpty
-func callbackQVBoxLayoutWithTriggerSlot_IsEmpty(ptr unsafe.Pointer) C.char {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).IsEmptyDefault())))
+	return C.char(int8(qt.GoBoolToInt(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).IsEmptyDefault())))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) IsEmptyDefault() bool {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) IsEmptyDefault() bool {
 	if ptr.Pointer() != nil {
-		return C.QVBoxLayoutWithTriggerSlot_IsEmptyDefault(ptr.Pointer()) != 0
+		return C.QRoomVBoxLayoutWithTriggerSlot_IsEmptyDefault(ptr.Pointer()) != 0
 	}
 	return false
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_IndexOf
-func callbackQVBoxLayoutWithTriggerSlot_IndexOf(ptr unsafe.Pointer, widget unsafe.Pointer) C.int {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).IndexOfDefault(std_widgets.NewQWidgetFromPointer(widget))))
+	return C.int(int32(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).IndexOfDefault(std_widgets.NewQWidgetFromPointer(widget))))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) IndexOfDefault(widget std_widgets.QWidget_ITF) int {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) IndexOfDefault(widget std_widgets.QWidget_ITF) int {
 	if ptr.Pointer() != nil {
-		return int(int32(C.QVBoxLayoutWithTriggerSlot_IndexOfDefault(ptr.Pointer(), std_widgets.PointerFromQWidget(widget))))
+		return int(int32(C.QRoomVBoxLayoutWithTriggerSlot_IndexOfDefault(ptr.Pointer(), std_widgets.PointerFromQWidget(widget))))
 	}
 	return 0
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_Event
-func callbackQVBoxLayoutWithTriggerSlot_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).EventDefault(std_core.NewQEventFromPointer(e)))))
+	return C.char(int8(qt.GoBoolToInt(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).EventDefault(std_core.NewQEventFromPointer(e)))))
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) EventDefault(e std_core.QEvent_ITF) bool {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) EventDefault(e std_core.QEvent_ITF) bool {
 	if ptr.Pointer() != nil {
-		return C.QVBoxLayoutWithTriggerSlot_EventDefault(ptr.Pointer(), std_core.PointerFromQEvent(e)) != 0
+		return C.QRoomVBoxLayoutWithTriggerSlot_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 {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).EventFilterDefault(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 *QVBoxLayoutWithTriggerSlot) EventFilterDefault(watched std_core.QObject_ITF, event std_core.QEvent_ITF) bool {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) 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 C.QRoomVBoxLayoutWithTriggerSlot_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) {
+//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 {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).ConnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).ConnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) ConnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) ConnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
+		C.QRoomVBoxLayoutWithTriggerSlot_ConnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_CustomEvent
-func callbackQVBoxLayoutWithTriggerSlot_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
+//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 {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).CustomEventDefault(std_core.NewQEventFromPointer(event))
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).CustomEventDefault(std_core.NewQEventFromPointer(event))
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) CustomEventDefault(event std_core.QEvent_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) CustomEventDefault(event std_core.QEvent_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_CustomEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
+		C.QRoomVBoxLayoutWithTriggerSlot_CustomEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_DeleteLater
-func callbackQVBoxLayoutWithTriggerSlot_DeleteLater(ptr unsafe.Pointer) {
+//export callbackQRoomVBoxLayoutWithTriggerSlot_DeleteLater
+func callbackQRoomVBoxLayoutWithTriggerSlot_DeleteLater(ptr unsafe.Pointer) {
 	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
 		signal.(func())()
 	} else {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).DeleteLaterDefault()
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).DeleteLaterDefault()
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) DeleteLaterDefault() {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) DeleteLaterDefault() {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_DeleteLaterDefault(ptr.Pointer())
+		C.QRoomVBoxLayoutWithTriggerSlot_DeleteLaterDefault(ptr.Pointer())
 		ptr.SetPointer(nil)
 		runtime.SetFinalizer(ptr, nil)
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_Destroyed
-func callbackQVBoxLayoutWithTriggerSlot_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
+//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 callbackQVBoxLayoutWithTriggerSlot_DisconnectNotify
-func callbackQVBoxLayoutWithTriggerSlot_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
+//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 {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).DisconnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).DisconnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) DisconnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) DisconnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
+		C.QRoomVBoxLayoutWithTriggerSlot_DisconnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_ObjectNameChanged
-func callbackQVBoxLayoutWithTriggerSlot_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_Moc_PackedString) {
+//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 callbackQVBoxLayoutWithTriggerSlot_TimerEvent
-func callbackQVBoxLayoutWithTriggerSlot_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
+//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 {
-		NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).TimerEventDefault(std_core.NewQTimerEventFromPointer(event))
+		NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).TimerEventDefault(std_core.NewQTimerEventFromPointer(event))
 	}
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) TimerEventDefault(event std_core.QTimerEvent_ITF) {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) TimerEventDefault(event std_core.QTimerEvent_ITF) {
 	if ptr.Pointer() != nil {
-		C.QVBoxLayoutWithTriggerSlot_TimerEventDefault(ptr.Pointer(), std_core.PointerFromQTimerEvent(event))
+		C.QRoomVBoxLayoutWithTriggerSlot_TimerEventDefault(ptr.Pointer(), std_core.PointerFromQTimerEvent(event))
 	}
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_SpacerItem
-func callbackQVBoxLayoutWithTriggerSlot_SpacerItem(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).SpacerItemDefault())
+	return std_widgets.PointerFromQSpacerItem(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).SpacerItemDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) SpacerItemDefault() *std_widgets.QSpacerItem {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) SpacerItemDefault() *std_widgets.QSpacerItem {
 	if ptr.Pointer() != nil {
-		return std_widgets.NewQSpacerItemFromPointer(C.QVBoxLayoutWithTriggerSlot_SpacerItemDefault(ptr.Pointer()))
+		return std_widgets.NewQSpacerItemFromPointer(C.QRoomVBoxLayoutWithTriggerSlot_SpacerItemDefault(ptr.Pointer()))
 	}
 	return nil
 }
 
-//export callbackQVBoxLayoutWithTriggerSlot_Widget
-func callbackQVBoxLayoutWithTriggerSlot_Widget(ptr unsafe.Pointer) unsafe.Pointer {
+//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(NewQVBoxLayoutWithTriggerSlotFromPointer(ptr).WidgetDefault())
+	return std_widgets.PointerFromQWidget(NewQRoomVBoxLayoutWithTriggerSlotFromPointer(ptr).WidgetDefault())
 }
 
-func (ptr *QVBoxLayoutWithTriggerSlot) WidgetDefault() *std_widgets.QWidget {
+func (ptr *QRoomVBoxLayoutWithTriggerSlot) WidgetDefault() *std_widgets.QWidget {
 	if ptr.Pointer() != nil {
-		var tmpValue = std_widgets.NewQWidgetFromPointer(C.QVBoxLayoutWithTriggerSlot_WidgetDefault(ptr.Pointer()))
+		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) })
 		}
diff --git a/main.go b/main.go
@@ -45,6 +45,24 @@ func main() {
 	app.SetWindowIcon(appIcon)
 
 	window = widgets.NewQMainWindow(nil, 0)
+	/*window.SetWindowFlags(core.Qt__FramelessWindowHint)
+	var dragPositionX int
+	var dragPositionY int
+	window.ConnectMousePressEvent(func(event *gui.QMouseEvent) {
+		if event.Button() == core.Qt__LeftButton {
+			dragPositionX = event.GlobalX() - window.FrameGeometry().TopLeft().X()
+			dragPositionY = event.GlobalY() - window.FrameGeometry().TopLeft().Y()
+			event.Accept()
+		}
+	})
+
+	window.ConnectMouseMoveEvent(func(event *gui.QMouseEvent) {
+		if event.Button() == core.Qt__LeftButton {
+			window.Move2(event.GlobalX()-dragPositionX, event.GlobalY()-dragPositionY)
+			event.Accept()
+		}
+	})*/
+
 	windowHeight := 600
 	windowWidth := 950
 
diff --git a/qml/ui/chat.ui b/qml/ui/chat.ui
@@ -836,6 +836,9 @@ border-radius: 2px;</string>
           <property name="styleSheet">
            <string notr="true">border:0;</string>
           </property>
+          <property name="horizontalScrollBarPolicy">
+           <enum>Qt::ScrollBarAlwaysOff</enum>
+          </property>
           <property name="widgetResizable">
            <bool>true</bool>
           </property>
@@ -874,7 +877,7 @@ border-radius: 2px;</string>
             <height>0</height>
            </size>
           </property>
-          <layout class="QGridLayout" name="gridLayout_3">
+          <layout class="QGridLayout" name="gridLayout_3" rowstretch="0">
            <property name="leftMargin">
             <number>9</number>
            </property>
diff --git a/qml/ui/message.ui b/qml/ui/message.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>210</width>
-    <height>97</height>
+    <width>365</width>
+    <height>106</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -16,8 +16,20 @@
   <property name="styleSheet">
    <string notr="true">background-color:transparent;</string>
   </property>
-  <layout class="QFormLayout" name="formLayout">
-   <item row="0" column="0">
+  <layout class="QHBoxLayout" name="horizontalLayout_2">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item>
     <widget class="QWidget" name="widget_2" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
@@ -79,28 +91,10 @@
      </layout>
     </widget>
    </item>
-   <item row="0" column="1">
+   <item>
     <widget class="QWidget" name="widget" native="true">
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
-       <widget class="QLabel" name="sender">
-        <property name="font">
-         <font>
-          <pointsize>14</pointsize>
-         </font>
-        </property>
-        <property name="text">
-         <string>MTRNord</string>
-        </property>
-        <property name="openExternalLinks">
-         <bool>true</bool>
-        </property>
-        <property name="textInteractionFlags">
-         <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse</set>
-        </property>
-       </widget>
-      </item>
-      <item>
        <widget class="QLabel" name="messageContent">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
@@ -118,10 +112,9 @@
         <property name="styleSheet">
          <string notr="true">/*OLD COLOR
 background-color: rgb(242, 244, 248); */
-background-color: rgb(239, 239, 250);
+background-color: rgb(225, 227, 230);
 border: 0;
-border-radius:5px;
-</string>
+border-radius:7px;</string>
         </property>
         <property name="text">
          <string>Test</string>
@@ -146,6 +139,57 @@ border-radius:5px;
         </property>
        </widget>
       </item>
+      <item>
+       <widget class="QWidget" name="subMessageWidget" native="true">
+        <layout class="QHBoxLayout" name="horizontalLayout">
+         <item>
+          <widget class="QLabel" name="sender">
+           <property name="font">
+            <font>
+             <pointsize>8</pointsize>
+            </font>
+           </property>
+           <property name="styleSheet">
+            <string notr="true">color:grey;</string>
+           </property>
+           <property name="text">
+            <string>MTRNord</string>
+           </property>
+           <property name="openExternalLinks">
+            <bool>true</bool>
+           </property>
+           <property name="textInteractionFlags">
+            <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse</set>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLabel" name="timestamp">
+           <property name="font">
+            <font>
+             <pointsize>8</pointsize>
+            </font>
+           </property>
+           <property name="styleSheet">
+            <string notr="true">color:grey;</string>
+           </property>
+           <property name="text">
+            <string>Way to early to say a time^^</string>
+           </property>
+           <property name="alignment">
+            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+           </property>
+           <property name="openExternalLinks">
+            <bool>true</bool>
+           </property>
+           <property name="textInteractionFlags">
+            <set>Qt::LinksAccessibleByMouse</set>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
diff --git a/ui/MainUI.go b/ui/MainUI.go
@@ -89,16 +89,17 @@ func (m *MainUI) NewUI() (err error) {
 
 	m.window.ConnectResizeEvent(func(event *gui.QResizeEvent) {
 		widget.Resize2(event.Size().Width(), event.Size().Height())
-
+		event.Accept()
 	})
 
 	widget.ConnectResizeEvent(func(event *gui.QResizeEvent) {
 		mainWidget.Resize2(event.Size().Width(), event.Size().Height())
-
+		event.Accept()
 	})
 
 	messageScrollArea.ConnectResizeEvent(func(event *gui.QResizeEvent) {
 		messageScrollArea.Resize(event.Size())
+		event.Accept()
 	})
 
 	//Set Avatar
@@ -151,8 +152,10 @@ func (m *MainUI) NewUI() (err error) {
 			}
 
 			messageInput.Clear()
+			ev.Accept()
 		} else {
 			messageInput.KeyPressEventDefault(ev)
+			ev.Ignore()
 		}
 	})