apresleschats/conversationmodel.go at master · dnssec/apresleschats · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package main

import (
	"time"

	humanize "github.com/dustin/go-humanize"
	"github.com/therecipe/qt/core"
)

// Message holds the data for a message
type Message struct {
	core.QObject

	Nickname  string
	Avatar    string
	Message   string
	Timestamp time.Time
}

// ConversationModel holds a collection of messages
type ConversationModel struct {
	core.QAbstractListModel

	_ func() `constructor:"init"`

	_ map[int]*core.QByteArray `property:"roles"`
	_ []*Message               `property:"messages"`

	_ func(*Message) `slot:"addMessage"`
	_ func(*Message) `slot:"appendMessage"`
	_ func(int)      `slot:"removeMessage"`
	_ func()         `slot:"clear"`
}

func (m *ConversationModel) init() {
	m.SetRoles(map[int]*core.QByteArray{
		RoleNickname:  core.NewQByteArray2("nickname", -1),
		RoleAvatar:    core.NewQByteArray2("avatar", -1),
		RoleMessage:   core.NewQByteArray2("message", -1),
		RoleTimestamp: core.NewQByteArray2("timestamp", -1),
	})

	m.ConnectData(m.data)
	m.ConnectRowCount(m.rowCount)
	m.ConnectColumnCount(m.columnCount)
	m.ConnectRoleNames(m.roleNames)

	m.ConnectAddMessage(m.addMessage)
	m.ConnectAppendMessage(m.appendMessage)
	m.ConnectRemoveMessage(m.removeMessage)
	m.ConnectClear(m.clear)
}

func (m *ConversationModel) data(index *core.QModelIndex, role int) *core.QVariant {
	if !index.IsValid() {
		return core.NewQVariant()
	}
	if index.Row() >= len(m.Messages()) {
		return core.NewQVariant()
	}

	var p = m.Messages()[len(m.Messages())-1-index.Row()]
	if p == nil {
		return core.NewQVariant()
	}

	switch role {
	case RoleNickname:
		{
			return core.NewQVariant1(p.Nickname)
		}
	case RoleAvatar:
		{
			return core.NewQVariant1(p.Avatar)
		}
	case RoleMessage:
		{
			return core.NewQVariant1(p.Message)
		}
	case RoleTimestamp:
		{
			return core.NewQVariant1(humanize.Time(p.Timestamp))
		}

	default:
		{
			return core.NewQVariant()
		}
	}
}

func (m *ConversationModel) rowCount(parent *core.QModelIndex) int {
	return len(m.Messages())
}

func (m *ConversationModel) columnCount(parent *core.QModelIndex) int {
	return 1
}

func (m *ConversationModel) roleNames() map[int]*core.QByteArray {
	return m.Roles()
}

func (m *ConversationModel) clear() {
	m.BeginResetModel()
	m.SetMessages([]*Message{})
	m.EndResetModel()
}

func (m *ConversationModel) addMessage(p *Message) {
	m.BeginInsertRows(core.NewQModelIndex(), 0, 0)
	m.SetMessages(append(m.Messages(), p))
	m.EndInsertRows()
}

func (m *ConversationModel) appendMessage(p *Message) {
	m.BeginInsertRows(core.NewQModelIndex(), len(m.Messages()), len(m.Messages()))
	m.SetMessages(append([]*Message{p}, m.Messages()...))
	m.EndInsertRows()
}

func (m *ConversationModel) removeMessage(row int) {
	trow := len(m.Messages()) - 1 - row
	m.BeginRemoveRows(core.NewQModelIndex(), row, row)
	m.SetMessages(append(m.Messages()[:trow], m.Messages()[trow+1:]...))
	m.EndRemoveRows()
}

func init() {
	ConversationModel_QRegisterMetaType()
	Message_QRegisterMetaType()
}