Differential D14815 Diff 39662 libs/widgets/KisPaletteModel.cpp

Changeset View

Standalone View

libs/widgets/KisPaletteModel.cpp

1	/*	1	/*
2	* Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>	2	* Copyright (c) 2013 Sven Langkamp <sven.langkamp@gmail.com>
		3	* Copyright (c) 2018 Michael Zhou <simeirxh@gmail.com>
3	*	4	*
4	* This program is free software; you can redistribute it and/or modify	5	* This program is free software; you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by	6	* it under the terms of the GNU General Public License as published by
Context not available.
31	#include <KoColorDisplayRendererInterface.h>	32	#include <KoColorDisplayRendererInterface.h>
32		33
33	KisPaletteModel::KisPaletteModel(QObject* parent)	34	KisPaletteModel::KisPaletteModel(QObject* parent)
34	: QAbstractTableModel(parent),	35	: QAbstractTableModel(parent)
35	m_colorSet(0),	36	, m_colorSet(Q_NULLPTR)
36	m_displayRenderer(KoDumbColorDisplayRenderer::instance())	37	, m_displayRenderer(KoDumbColorDisplayRenderer::instance())
37	{	38	{
		39	connect(this, SIGNAL(sigPaletteModified()), SLOT(slotPaletteModified()));
38	}	40	}
39		41
40	KisPaletteModel::~KisPaletteModel()	42	KisPaletteModel::~KisPaletteModel()
41	{	43	{
42	}	44	}
43		45
44	void KisPaletteModel::setDisplayRenderer(KoColorDisplayRendererInterface *displayRenderer)
45	{
46	if (displayRenderer) {
47	if (m_displayRenderer) {
48	disconnect(m_displayRenderer, 0, this, 0);
49	}
50	m_displayRenderer = displayRenderer;
51	connect(m_displayRenderer, SIGNAL(displayConfigurationChanged()),
52	SLOT(slotDisplayConfigurationChanged()));
53	} else {
54	m_displayRenderer = KoDumbColorDisplayRenderer::instance();
55	}
56	}
57
58	void KisPaletteModel::slotDisplayConfigurationChanged()
59	{
60	beginResetModel();
61	endResetModel();
62	}
63
64	QModelIndex KisPaletteModel::getLastEntryIndex()
65	{
66	int endRow = rowCount();
67	int endColumn = columnCount();
68	if (m_colorSet->nColors()>0) {
69	QModelIndex i = this->index(endRow, endColumn, QModelIndex());
70	while (qvariant_cast<QStringList>(i.data(RetrieveEntryRole)).isEmpty()) {
71	i = this->index(endRow, endColumn);
72	endColumn -=1;
73	if (endColumn<0) {
74	endColumn = columnCount();
75	endRow-=1;
76	}
77	}
78	return i;
79	}
80	return QModelIndex();
81	}
82
83	QVariant KisPaletteModel::data(const QModelIndex& index, int role) const	46	QVariant KisPaletteModel::data(const QModelIndex& index, int role) const
84	{	47	{
85	KoColorSetEntry entry;	48	if (!index.isValid()) { return QVariant(); }
86	if (m_colorSet && m_displayRenderer) {	49	bool groupNameRow = m_groupNameRows.contains(index.row());
87	//now to figure out whether we have a groupname row or not.	50	if (role == IsGroupNameRole) {
88	bool groupNameRow = false;	51	return groupNameRow;
89	quint32 indexInGroup = 0;	52	}
90	QString indexGroupName = QString();	53	if (groupNameRow) {
91		54	return dataForGroupNameRow(index, role);
92	int rowstotal = m_colorSet->nColorsGroup()/columnCount();	55	} else {
93	if (index.row()<=rowstotal && (quint32)(index.row()*columnCount()+index.column())<m_colorSet->nColorsGroup()) {	56	return dataForSwatch(index, role);
94	indexInGroup = (quint32)(index.row()*columnCount()+index.column());
95	}
96	if (m_colorSet->nColorsGroup()==0) {
97	rowstotal+=1; //always add one for the default group when considering groups.
98	}
99	Q_FOREACH (QString groupName, m_colorSet->getGroupNames()){
100	//we make an int for the rows added by the current group.
101	int newrows = 1+m_colorSet->nColorsGroup(groupName)/columnCount();
102	if (m_colorSet->nColorsGroup(groupName)%columnCount() > 0) {
103	newrows+=1;
104	}
105	if (newrows==0) {
106	newrows+=1; //always add one for the group when considering groups.
107	}
108	quint32 tempIndex = (quint32)((index.row()-(rowstotal+2))*columnCount()+index.column());
109	if (index.row() == rowstotal+1) {
110	//rowstotal+1 is taken up by the groupname.
111	indexGroupName = groupName;
112	groupNameRow = true;
113	} else if (index.row() > (rowstotal+1) && index.row() <= rowstotal+newrows &&
114	tempIndex<m_colorSet->nColorsGroup(groupName)){
115	//otherwise it's an index to the colors in the group.
116	indexGroupName = groupName;
117	indexInGroup = tempIndex;
118	}
119	//add the new rows to the totalrows we've looked at.
120	rowstotal += newrows;
121	}
122	if (groupNameRow) {
123	switch (role) {
124	case Qt::ToolTipRole:
125	case Qt::DisplayRole: {
126	return indexGroupName;
127	}
128	case IsHeaderRole: {
129	return true;
130	}
131	case RetrieveEntryRole: {
132	QStringList entryList;
133	entryList.append(indexGroupName);
134	entryList.append(QString::number(0));
135	return entryList;
136	}
137	}
138	} else {
139	if (indexInGroup < m_colorSet->nColorsGroup(indexGroupName)) {
140	entry = m_colorSet->getColorGroup(indexInGroup, indexGroupName);
141	switch (role) {
142	case Qt::ToolTipRole:
143	case Qt::DisplayRole: {
144	return entry.name();
145	}
146	case Qt::BackgroundRole: {
147	QColor color = m_displayRenderer->toQColor(entry.color());
148	return QBrush(color);
149	}
150	case IsHeaderRole: {
151	return false;
152	}
153	case RetrieveEntryRole: {
154	QStringList entryList;
155	entryList.append(indexGroupName);
156	entryList.append(QString::number(indexInGroup));
157	return entryList;
158	}
159	}
160	}
161	}
162	}	57	}
163	return QVariant();
164	}	58	}
165		59
166	int KisPaletteModel::rowCount(const QModelIndex& /parent/) const	60	int KisPaletteModel::rowCount(const QModelIndex& /parent/) const
167	{	61	{
168	if (!m_colorSet) {	62	if (!m_colorSet)
169	return 0;
170	}
171	if (m_colorSet->nColors()==0) {
172	return 0;	63	return 0;
173	}	64	return m_colorSet->rowCount() // count of color rows
174	if (columnCount() > 0) {	65	+ m_groupNameRows.size() // rows for names
175	int countedrows = m_colorSet->nColorsGroup("")/columnCount();	66	- 1; // global doesn't have a name
176	if (m_colorSet->nColorsGroup()%columnCount() > 0) {
177	countedrows+=1;
178	}
179	if (m_colorSet->nColorsGroup()==0) {
180	countedrows+=1;
181	}
182	Q_FOREACH (QString groupName, m_colorSet->getGroupNames()) {
183	countedrows += 1; //add one for the name;
184	countedrows += 1+(m_colorSet->nColorsGroup(groupName)/ columnCount());
185	if (m_colorSet->nColorsGroup(groupName)%columnCount() > 0) {
186	countedrows+=1;
187	}
188	if (m_colorSet->nColorsGroup(groupName)==0) {
189	countedrows+=1;
190	}
191	}
192	countedrows +=1; //Our code up till now doesn't take 0 into account.
193	return countedrows;
194	}
195	return m_colorSet->nColors()/15 + 1;
196	}	67	}
197		68
198	int KisPaletteModel::columnCount(const QModelIndex& /parent/) const	69	int KisPaletteModel::columnCount(const QModelIndex& /parent/) const
Context not available.
200	if (m_colorSet && m_colorSet->columnCount() > 0) {	71	if (m_colorSet && m_colorSet->columnCount() > 0) {
201	return m_colorSet->columnCount();	72	return m_colorSet->columnCount();
202	}	73	}
203	return 15;	74	if (!m_colorSet) {
		75	return 0;
		76	}
		77	return 16;
204	}	78	}
205		79
206	Qt::ItemFlags KisPaletteModel::flags(const QModelIndex& index) const	80	Qt::ItemFlags KisPaletteModel::flags(const QModelIndex& index) const
207	{	81	{
208	if (index.isValid()) {	82	if (index.isValid()) {
209	return Qt::ItemIsSelectable \| Qt::ItemIsEnabled	83	return Qt::ItemIsSelectable \|
210	\| Qt::ItemIsUserCheckable	84	Qt::ItemIsEnabled \|
211	\| Qt::ItemIsDragEnabled \| Qt::ItemIsDropEnabled;	85	Qt::ItemIsUserCheckable \|
		86	Qt::ItemIsDragEnabled \|
		87	Qt::ItemIsDropEnabled;
212	}	88	}
213	return Qt::ItemIsDropEnabled;	89	return Qt::ItemIsDropEnabled;
214	}	90	}
215		91
216	QModelIndex KisPaletteModel::index(int row, int column, const QModelIndex& parent) const	92	QModelIndex KisPaletteModel::index(int row, int column, const QModelIndex& parent) const
217	{	93	{
218	if (m_colorSet) {	94	Q_UNUSED(parent);
219		95	Q_ASSERT(m_colorSet);
220	//make an int to hold the amount of rows we've looked at. The initial is the total rows in the default group.	96	int groupNameRow = groupNameRowForRow(row);
221	int rowstotal = m_colorSet->nColorsGroup()/columnCount();	97	KisSwatchGroup *group = m_colorSet->getGroup(m_groupNameRows[groupNameRow]);
222	if (row<=rowstotal && (quint32)(row*columnCount()+column)<m_colorSet->nColorsGroup()) {	98	Q_ASSERT(group);
223	//if the total rows are in the default group, we just return an index.	99	return createIndex(row, column, group);
224	return QAbstractTableModel::index(row, column, parent);
225	} else if(row<0 && column<0) {
226	return QAbstractTableModel::index(0, 0, parent);
227	}
228	if (m_colorSet->nColorsGroup()==0) {
229	rowstotal+=1; //always add one for the default group when considering groups.
230	}
231	Q_FOREACH (QString groupName, m_colorSet->getGroupNames()){
232	//we make an int for the rows added by the current group.
233	int newrows = 1+m_colorSet->nColorsGroup(groupName)/columnCount();
234	if (m_colorSet->nColorsGroup(groupName)%columnCount() > 0) {
235	newrows+=1;
236	}
237	if (m_colorSet->nColorsGroup(groupName)==0) {
238	newrows+=1; //always add one for the group when considering groups.
239	}
240	if (rowstotal + newrows>rowCount()) {
241	newrows = rowCount() - rowstotal;
242	}
243	quint32 tempIndex = (quint32)((row-(rowstotal+2))*columnCount()+column);
244	if (row == rowstotal+1) {
245	//rowstotal+1 is taken up by the groupname.
246	return QAbstractTableModel::index(row, 0, parent);
247	} else if (row > (rowstotal+1) && row <= rowstotal+newrows && tempIndex<m_colorSet->nColorsGroup(groupName)){
248	//otherwise it's an index to the colors in the group.
249	return QAbstractTableModel::index(row, column, parent);
250	}
251	//add the new rows to the totalrows we've looked at.
252	rowstotal += newrows;
253	}
254	}
255	return QModelIndex();
256	}	100	}
257		101
258	void KisPaletteModel::setColorSet(KoColorSet* colorSet)	102	void KisPaletteModel::setPalette(KoColorSet* palette)
259	{	103	{
260	m_colorSet = colorSet;
261	beginResetModel();	104	beginResetModel();
		105	m_groupNameRows.clear();
		106	m_colorSet = palette;
		107	if (palette) {
		108	int row = -1;
		109	for (const QString &groupName : m_colorSet->getGroupNames()) {
		110	m_groupNameRows[row] = groupName;
		111	row += m_colorSet->getGroup(groupName)->rowCount();
		112	row += 1; // row for group name
		113	}
		114	}
262	endResetModel();	115	endResetModel();
		116	emit sigPaletteChanged();
263	}	117	}
264		118
265	KoColorSet* KisPaletteModel::colorSet() const	119	KoColorSet* KisPaletteModel::colorSet() const
Context not available.
267	return m_colorSet;	121	return m_colorSet;
268	}	122	}
269		123
270	QModelIndex KisPaletteModel::indexFromId(int i) const	124	int KisPaletteModel::rowNumberInGroup(int rowInModel) const
271	{
272	QModelIndex index = QModelIndex();
273	if (!colorSet() \|\| colorSet()->nColors() == 0) {
274	return index;
275	}
276
277	if (i > (int)colorSet()->nColors()) {
278	qWarning()<<"index is too big"<<i<<"/"<<colorSet()->nColors();
279	index = this->index(0,0);
280	}
281
282	if (i < (int)colorSet()->nColorsGroup(0)) {
283	index = QAbstractTableModel::index(i/columnCount(), i % columnCount());
284	if (!index.isValid()) {
285	index = QAbstractTableModel::index(0, 0, QModelIndex());
286	}
287	return index;
288	} else {
289	int rowstotal = 1 + m_colorSet->nColorsGroup() / columnCount();
290	if (m_colorSet->nColorsGroup() == 0) {
291	rowstotal += 1;
292	}
293	int totalIndexes = colorSet()->nColorsGroup();
294	Q_FOREACH (QString groupName, m_colorSet->getGroupNames()){
295	if (i + 1 <= (int)(totalIndexes + colorSet()->nColorsGroup(groupName)) && i + 1 > (int)totalIndexes) {
296	int col = (i - totalIndexes) % columnCount();
297	int row = rowstotal + 1 + ((i - totalIndexes) / columnCount());
298	index = this->index(row, col);
299	return index;
300	} else {
301	rowstotal += 1 + m_colorSet->nColorsGroup(groupName) / columnCount();
302	totalIndexes += colorSet()->nColorsGroup(groupName);
303	if (m_colorSet->nColorsGroup(groupName)%columnCount() > 0) {
304	rowstotal += 1;
305	}
306	if (m_colorSet->nColorsGroup(groupName)==0) {
307	rowstotal += 1; //always add one for the group when considering groups.
308	}
309	}
310	}
311	}
312	return index;
313	}
314
315	int KisPaletteModel::idFromIndex(const QModelIndex &index) const
316	{	125	{
317	if (index.isValid()==false) {	126	if (m_groupNameRows.contains(rowInModel)) {
318	return -1;
319	qWarning()<<"invalid index";
320	}
321	int i=0;
322	QStringList entryList = qvariant_cast<QStringList>(data(index, RetrieveEntryRole));
323	if (entryList.isEmpty()) {
324	return -1;	127	return -1;
325	qWarning()<<"invalid index, there's no data to retrieve here";
326	}
327	if (entryList.at(0)==QString()) {
328	return entryList.at(1).toUInt();
329	}	128	}
330		129	for (auto it = m_groupNameRows.keys().rbegin(); it != m_groupNameRows.keys().rend(); it++) {
331	i = colorSet()->nColorsGroup("");	130	if (*it < rowInModel) {
332	//find at which position the group is.	131	return rowInModel - *it - 1;
333	int groupIndex = colorSet()->getGroupNames().indexOf(entryList.at(0));	132	}
334	//add all the groupsizes onto it till we get to our group.
335	for(int g=0; g<groupIndex; g++) {
336	i+=colorSet()->nColorsGroup(colorSet()->getGroupNames().at(g));
337	}
338	//then add the index.
339	i += entryList.at(1).toUInt();
340	return i;
341	}
342
343	KoColorSetEntry KisPaletteModel::colorSetEntryFromIndex(const QModelIndex &index) const
344	{
345	KoColorSetEntry blank = KoColorSetEntry();
346	if (!index.isValid()) {
347	return blank;
348	}
349	QStringList entryList = qvariant_cast<QStringList>(data(index, RetrieveEntryRole));
350	if (entryList.isEmpty()) {
351	return blank;
352	}	133	}
353	QString groupName = entryList.at(0);	134	return rowInModel;
354	quint32 indexInGroup = entryList.at(1).toUInt();
355	return m_colorSet->getColorGroup(indexInGroup, groupName);
356	}	135	}
357		136
358	bool KisPaletteModel::addColorSetEntry(KoColorSetEntry entry, QString groupName)	137	bool KisPaletteModel::addEntry(const KisSwatch &entry, const QString &groupName)
359	{	138	{
360	int col = m_colorSet->nColorsGroup(groupName)%columnCount();	139	beginInsertRows(QModelIndex(), rowCount(), rowCount() + 1);
361	QModelIndex i = getLastEntryIndex();
362	if (col+1 > columnCount()) {
363	beginInsertRows(QModelIndex(), i.row(), i.row()+1);
364	}
365	if ((int)m_colorSet->nColors() < columnCount()) {
366	beginInsertColumns(QModelIndex(), m_colorSet->nColors(), m_colorSet->nColors()+1);
367	}
368	m_colorSet->add(entry, groupName);	140	m_colorSet->add(entry, groupName);
369	if (col + 1 > columnCount()) {	141	endInsertRows();
370	endInsertRows();	142	if (m_colorSet->isGlobal()) {
371	}	143	m_colorSet->save();
372	if (m_colorSet->nColors() < (quint32)columnCount()) {
373	endInsertColumns();
374	}	144	}
		145	emit sigPaletteModified();
375	return true;	146	return true;
376	}	147	}
377		148
378	bool KisPaletteModel::removeEntry(QModelIndex index, bool keepColors)	149	bool KisPaletteModel::removeEntry(const QModelIndex &index, bool keepColors)
379	{	150	{
380	QStringList entryList = qvariant_cast<QStringList>(index.data(RetrieveEntryRole));	151	if (!qvariant_cast<bool>(data(index, IsGroupNameRole))) {
381	if (entryList.empty()) {	152	static_cast<KisSwatchGroup*>(index.internalPointer())->removeEntry(index.column(),
382	return false;	153	rowNumberInGroup(index.row()));
383	}	154	emit dataChanged(index, index);
384	QString groupName = entryList.at(0);
385	quint32 indexInGroup = entryList.at(1).toUInt();
386
387	if (qvariant_cast<bool>(index.data(IsHeaderRole))==false) {
388	if (index.column()-1<0
389	&& m_colorSet->nColorsGroup(groupName)%columnCount() <1
390	&& index.row()-1>0
391	&& m_colorSet->nColorsGroup(groupName)/columnCount()>0) {
392	beginRemoveRows(QModelIndex(), index.row(), index.row()-1);
393	}
394	m_colorSet->removeAt(indexInGroup, groupName);
395	if (index.column()-1<0
396	&& m_colorSet->nColorsGroup(groupName)%columnCount() <1
397	&& index.row()-1>0
398	&& m_colorSet->nColorsGroup(groupName)/columnCount()>0) {
399	endRemoveRows();
400	}
401	} else {	155	} else {
402	beginRemoveRows(QModelIndex(), index.row(), index.row()-1);	156	int groupNameRow = groupNameRowForRow(index.row());
403	m_colorSet->removeGroup(groupName, keepColors);	157	QString groupName = m_groupNameRows[groupNameRow];
404	endRemoveRows();	158	removeGroup(groupName, keepColors);
405	}	159	}
		160	emit sigPaletteModified();
406	return true;	161	return true;
407	}	162	}
408		163
409	bool KisPaletteModel::addGroup(QString groupName)	164	void KisPaletteModel::removeGroup(const QString &groupName, bool keepColors)
410	{	165	{
411	QModelIndex i = getLastEntryIndex();	166	beginResetModel();
412	beginInsertRows(QModelIndex(), i.row(), i.row()+1);	167	m_colorSet->removeGroup(groupName, keepColors);
413	m_colorSet->addGroup(groupName);	168	m_groupNameRows.clear();
414	endInsertRows();	169	int row = -1;
415	return true;	170	for (const QString &groupName : m_colorSet->getGroupNames()) {
416	}	171	m_groupNameRows[row] = groupName;
417		172	row += m_colorSet->getGroup(groupName)->rowCount();
418	bool KisPaletteModel::removeRows(int row, int count, const QModelIndex &parent)	173	row += 1; // row for group name
419	{	174	}
420	Q_ASSERT(!parent.isValid());	175	endResetModel();
421
422	int beginRow = qMax(0, row);
423	int endRow = qMin(row + count - 1, (int)m_colorSet->nColors() - 1);
424	beginRemoveRows(parent, beginRow, endRow);
425
426	// Find the palette entry at row, count, remove from KoColorSet
427
428	endRemoveRows();
429	return true;
430	}	176	}
431		177
432	bool KisPaletteModel::dropMimeData(const QMimeData *data, Qt::DropAction action,	178	bool KisPaletteModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
433	int row, int column, const QModelIndex &parent)	179	int row, int column, const QModelIndex &parent)
434	{	180	{
		181	Q_UNUSED(row);
		182	Q_UNUSED(column);
435	if (!data->hasFormat("krita/x-colorsetentry") && !data->hasFormat("krita/x-colorsetgroup")) {	183	if (!data->hasFormat("krita/x-colorsetentry") && !data->hasFormat("krita/x-colorsetgroup")) {
436	return false;	184	return false;
437	}	185	}
Context not available.
439	return false;	187	return false;
440	}	188	}
441		189
442	int endRow;
443	int endColumn;
444
445	if (!parent.isValid()) {
446	if (row < 0) {
447	endRow = indexFromId(m_colorSet->nColors()).row();
448	endColumn = indexFromId(m_colorSet->nColors()).column();
449	} else {
450	endRow = qMin(row, indexFromId(m_colorSet->nColors()).row());
451	endColumn = qMin(column, m_colorSet->columnCount());
452	}
453	} else {
454	endRow = qMin(parent.row(), rowCount());
455	endColumn = qMin(parent.column(), columnCount());
456	}
457
458	if (data->hasFormat("krita/x-colorsetgroup")) {	190	if (data->hasFormat("krita/x-colorsetgroup")) {
		191	// dragging group not supported for now
		192	/*
459	QByteArray encodedData = data->data("krita/x-colorsetgroup");	193	QByteArray encodedData = data->data("krita/x-colorsetgroup");
460	QDataStream stream(&encodedData, QIODevice::ReadOnly);	194	QDataStream stream(&encodedData, QIODevice::ReadOnly);
461		195
Context not available.
477		211
478	++endRow;	212	++endRow;
479	}	213	}
480	}	214	*/
481	} else {	215	return true;
482	QByteArray encodedData = data->data("krita/x-colorsetentry");	216	}
483	QDataStream stream(&encodedData, QIODevice::ReadOnly);
484		217
485	while (!stream.atEnd()) {	218	QModelIndex finalIdx = parent;
486	KoColorSetEntry entry;	219	if (!finalIdx.isValid()) { return false; }
487	QString oldGroupName;
488	int indexInGroup;
489	QString colorXml;
490
491	QString name, id;
492	bool spotColor;
493	stream >> name
494	>> id
495	>> spotColor
496	>> indexInGroup
497	>> oldGroupName
498	>> colorXml;
499	entry.setName(name);
500	entry.setId(id);
501	entry.setSpotColor(spotColor);
502		220
503	QDomDocument doc;	221	if (qvariant_cast<bool>(finalIdx.data(KisPaletteModel::IsGroupNameRole))) {
504	doc.setContent(colorXml);	222	return true;
505	QDomElement e = doc.documentElement();	223	}
506	QDomElement c = e.firstChildElement();	224	QByteArray encodedData = data->data("krita/x-colorsetentry");
507	if (!c.isNull()) {	225	QDataStream stream(&encodedData, QIODevice::ReadOnly);
508	QString colorDepthId = c.attribute("bitdepth", Integer8BitsColorDepthID.id());	226
509	entry.setColor(KoColor::fromXML(c, colorDepthId));	227	while (!stream.atEnd()) {
510	}	228	KisSwatch entry;
		229
		230	QString name, id;
		231	bool spotColor;
		232	QString oldGroupName;
		233	int oriRow;
		234	int oriColumn;
		235	QString colorXml;
		236
		237	stream >> name >> id >> spotColor
		238	>> oriRow >> oriColumn
		239	>> oldGroupName
		240	>> colorXml;
		241
		242	entry.setName(name);
		243	entry.setId(id);
		244	entry.setSpotColor(spotColor);
		245
		246	QDomDocument doc;
		247	doc.setContent(colorXml);
		248	QDomElement e = doc.documentElement();
		249	QDomElement c = e.firstChildElement();
		250	if (!c.isNull()) {
		251	QString colorDepthId = c.attribute("bitdepth", Integer8BitsColorDepthID.id());
		252	entry.setColor(KoColor::fromXML(c, colorDepthId));
		253	}
511		254
512	QModelIndex index = this->index(endRow, endColumn);	255	if (action == Qt::MoveAction){
513	if (qvariant_cast<bool>(index.data(IsHeaderRole))){	256	KisSwatchGroup *g = m_colorSet->getGroup(oldGroupName);
514	endRow+=1;	257	if (g) {
515	}	258	if (qvariant_cast<bool>(finalIdx.data(KisPaletteModel::CheckSlotRole))) {
516	if (index.isValid()) {	259	g->setEntry(getEntry(finalIdx), oriColumn, oriRow);
517	/*this is to figure out the row of the old color.
518	* That way we can in turn avoid moverows from complaining the
519	* index is out of bounds when using index.
520	* Makes me wonder if we shouldn't just insert the index of the
521	* old color when requesting the mimetype...
522	*/
523	int i = indexInGroup;
524	if (oldGroupName != QString()) {
525	colorSet()->nColorsGroup("");
526	//find at which position the group is.
527	int groupIndex = colorSet()->getGroupNames().indexOf(oldGroupName);
528	//add all the groupsizes onto it till we get to our group.
529	for(int g=0; g<groupIndex; g++) {
530	i+=colorSet()->nColorsGroup(colorSet()->getGroupNames().at(g));
531	}
532	}
533	QModelIndex indexOld = indexFromId(i);
534	if (action == Qt::MoveAction){
535	if (indexOld.row()!=qMax(endRow, 0) && indexOld.row()!=qMax(endRow+1,1)) {
536	beginMoveRows(QModelIndex(), indexOld.row(), indexOld.row(), QModelIndex(), qMax(endRow+1,1));
537	}
538	if (indexOld.column()!=qMax(endColumn, 0) && indexOld.column()!=qMax(endColumn+1,1)) {
539	beginMoveColumns(QModelIndex(), indexOld.column(), indexOld.column(), QModelIndex(), qMax(endColumn+1,1));
540	}
541	} else {	260	} else {
542	beginInsertRows(QModelIndex(), endRow, endRow);	261	g->removeEntry(oriColumn, oriRow);
543	}
544	QStringList entryList = qvariant_cast<QStringList>(index.data(RetrieveEntryRole));
545	QString entryInGroup = "0";
546	QString groupName = QString();
547	if (!entryList.isEmpty()) {
548	groupName = entryList.at(0);
549	entryInGroup = entryList.at(1);
550	}
551
552	int location = entryInGroup.toInt();
553	// Insert the entry
554	if (groupName==oldGroupName && qvariant_cast<bool>(index.data(IsHeaderRole))==true) {
555	groupName=QString();
556	location=m_colorSet->nColorsGroup();
557	}
558	m_colorSet->insertBefore(entry, location, groupName);
559	if (groupName==oldGroupName && location<indexInGroup) {
560	indexInGroup+=1;
561	}
562	if (action == Qt::MoveAction){
563	m_colorSet->removeAt(indexInGroup, oldGroupName);
564	}	262	}
		263	}
		264	setEntry(entry, finalIdx);
		265	emit sigPaletteModified();
		266	if (m_colorSet->isGlobal()) {
565	m_colorSet->save();	267	m_colorSet->save();
566	if (action == Qt::MoveAction){
567	if (indexOld.row()!=qMax(endRow, 0) && indexOld.row()!=qMax(endRow+1,1)) {
568	endMoveRows();
569	}
570	if (indexOld.column()!=qMax(endColumn, 0) && indexOld.column()!=qMax(endColumn+1,1)) {
571	endMoveColumns();
572	}
573
574	} else {
575	endInsertRows();
576	}
577
578	++endRow;
579	}	268	}
580	}	269	}
581	}	270	}
Context not available.
589	QByteArray encodedData;	278	QByteArray encodedData;
590		279
591	QDataStream stream(&encodedData, QIODevice::WriteOnly);	280	QDataStream stream(&encodedData, QIODevice::WriteOnly);
592	QString mimeTypeName = "krita/x-colorsetentry";
593	//Q_FOREACH(const QModelIndex &index, indexes) {
594	QModelIndex index = indexes.last();	281	QModelIndex index = indexes.last();
595	if (index.isValid()) {	282	if (index.isValid() && qvariant_cast<bool>(index.data(CheckSlotRole))) {
596	if (qvariant_cast<bool>(index.data(IsHeaderRole))==false) {	283	QString mimeTypeName = "krita/x-colorsetentry";
597	KoColorSetEntry entry = colorSetEntryFromIndex(index);	284	if (qvariant_cast<bool>(index.data(IsGroupNameRole))==false) {
598	QStringList entryList = qvariant_cast<QStringList>(index.data(RetrieveEntryRole));	285	KisSwatch entry = getEntry(index);
599	QString groupName = QString();
600	int indexInGroup = 0;
601	if (!entryList.isEmpty()) {
602	groupName = entryList.at(0);
603	QString iig = entryList.at(1);
604	indexInGroup = iig.toInt();
605	}
606		286
607	QDomDocument doc;	287	QDomDocument doc;
608	QDomElement root = doc.createElement("Color");	288	QDomElement root = doc.createElement("Color");
Context not available.
610	doc.appendChild(root);	290	doc.appendChild(root);
611	entry.color().toXML(doc, root);	291	entry.color().toXML(doc, root);
612		292
613	stream << entry.name()	293	stream << entry.name() << entry.id() << entry.spotColor()
614	<< entry.id()	294	<< rowNumberInGroup(index.row()) << index.column()
615	<< entry.spotColor()	295	<< qvariant_cast<QString>(index.data(GroupNameRole))
616	<< indexInGroup
617	<< groupName
618	<< doc.toString();	296	<< doc.toString();
619	} else {	297	} else {
620	mimeTypeName = "krita/x-colorsetgroup";	298	mimeTypeName = "krita/x-colorsetgroup";
Context not available.
625	}	303	}
626	stream << groupName;	304	stream << groupName;
627	}	305	}
		306	mimeData->setData(mimeTypeName, encodedData);
628	}	307	}
629		308
630	mimeData->setData(mimeTypeName, encodedData);
631	return mimeData;	309	return mimeData;
632	}	310	}
633		311
Context not available.
640	{	318	{
641	return Qt::MoveAction;	319	return Qt::MoveAction;
642	}	320	}
		321
		322	void KisPaletteModel::setEntry(const KisSwatch &entry,
		323	const QModelIndex &index)
		324	{
		325	KisSwatchGroup group = static_cast<KisSwatchGroup>(index.internalPointer());
		326	Q_ASSERT(group);
		327	group->setEntry(entry, index.column(), rowNumberInGroup(index.row()));
		328	emit sigPaletteModified();
		329	emit dataChanged(index, index);
		330	if (m_colorSet->isGlobal()) {
		331	m_colorSet->save();
		332	}
		333	}
		334
		335	bool KisPaletteModel::renameGroup(const QString &groupName, const QString &newName)
		336	{
		337	beginResetModel();
		338	bool success = m_colorSet->changeGroupName(groupName, newName);
		339	for (auto it = m_groupNameRows.begin(); it != m_groupNameRows.end(); it++) {
		340	if (it.value() == groupName) {
		341	m_groupNameRows[it.key()] = newName;
		342	break;
		343	}
		344	}
		345	endResetModel();
		346	emit sigPaletteModified();
		347	return success;
		348	}
		349
		350	void KisPaletteModel::addGroup(const KisSwatchGroup &group)
		351	{
		352	beginInsertRows(QModelIndex(), rowCount(), rowCount() + group.rowCount());
		353	m_colorSet->addGroup(group.name());
		354	*m_colorSet->getGroup(group.name()) = group;
		355	endInsertColumns();
		356
		357	emit sigPaletteModified();
		358	}
		359
		360	void KisPaletteModel::setRowNumber(const QString &groupName, int rowCount)
		361	{
		362	beginResetModel();
		363	KisSwatchGroup *g = m_colorSet->getGroup(groupName);
		364	if (g) {
		365	g->setRowCount(rowCount);
		366	}
		367	endResetModel();
		368	}
		369
		370	void KisPaletteModel::clear()
		371	{
		372	beginResetModel();
		373	m_colorSet->clear();
		374	endResetModel();
		375	}
		376
		377	QVariant KisPaletteModel::dataForGroupNameRow(const QModelIndex &idx, int role) const
		378	{
		379	KisSwatchGroup group = static_cast<KisSwatchGroup>(idx.internalPointer());
		380	Q_ASSERT(group);
		381	QString groupName = group->name();
		382	switch (role) {
		383	case Qt::ToolTipRole:
		384	case Qt::DisplayRole: {
		385	return groupName;
		386	}
		387	case GroupNameRole: {
		388	return groupName;
		389	}
		390	case CheckSlotRole: {
		391	return true;
		392	}
		393	case RowInGroupRole: {
		394	return -1;
		395	}
		396	default: {
		397	return QVariant();
		398	}
		399	}
		400	}
		401
		402	QVariant KisPaletteModel::dataForSwatch(const QModelIndex &idx, int role) const
		403	{
		404	KisSwatchGroup group = static_cast<KisSwatchGroup>(idx.internalPointer());
		405	Q_ASSERT(group);
		406	int rowInGroup = rowNumberInGroup(idx.row());
		407	bool entryPresent = group->checkEntry(idx.column(), rowInGroup);
		408	KisSwatch entry;
		409	if (entryPresent) {
		410	entry = group->getEntry(idx.column(), rowInGroup);
		411	}
		412	switch (role) {
		413	case Qt::ToolTipRole:
		414	case Qt::DisplayRole: {
		415	return entryPresent ? entry.name() : i18n("Empty slot");
		416	}
		417	case Qt::BackgroundRole: {
		418	QColor color(0, 0, 0, 0);
		419	if (entryPresent) {
		420	color = m_displayRenderer->toQColor(entry.color());
		421	}
		422	return QBrush(color);
		423	}
		424	case GroupNameRole: {
		425	return group->name();
		426	}
		427	case CheckSlotRole: {
		428	return entryPresent;
		429	}
		430	case RowInGroupRole: {
		431	return rowInGroup;
		432	}
		433	default: {
		434	return QVariant();
		435	}
		436	}
		437	}
		438
		439	void KisPaletteModel::setDisplayRenderer(const KoColorDisplayRendererInterface *displayRenderer)
		440	{
		441	if (displayRenderer) {
		442	if (m_displayRenderer) {
		443	disconnect(m_displayRenderer, 0, this, 0);
		444	}
		445	m_displayRenderer = displayRenderer;
		446	connect(m_displayRenderer, SIGNAL(displayConfigurationChanged()),
		447	SLOT(slotDisplayConfigurationChanged()));
		448	} else {
		449	m_displayRenderer = KoDumbColorDisplayRenderer::instance();
		450	}
		451	}
		452
		453	void KisPaletteModel::slotDisplayConfigurationChanged()
		454	{
		455	beginResetModel();
		456	endResetModel();
		457	}
		458
		459	void KisPaletteModel::slotPaletteModified() {
		460	m_colorSet->setPaletteType(KoColorSet::KPL);
		461	}
		462
		463	QModelIndex KisPaletteModel::indexForClosest(const KoColor &compare)
		464	{
		465	KisSwatchGroup::SwatchInfo info = colorSet()->getClosestColorInfo(compare);
		466	return createIndex(indexRowForInfo(info), info.column, colorSet()->getGroup(info.group));
		467	}
		468
		469	int KisPaletteModel::indexRowForInfo(const KisSwatchGroup::SwatchInfo &info)
		470	{
		471	for (auto it = m_groupNameRows.begin(); it != m_groupNameRows.end(); it++) {
		472	if (it.value() == info.group) {
		473	return it.key() + info.row + 1;
		474	}
		475	}
		476	return info.row;
		477	}
		478
		479	KisSwatch KisPaletteModel::getEntry(const QModelIndex &index) const
		480	{
		481	KisSwatchGroup group = static_cast<KisSwatchGroup>(index.internalPointer());
		482	if (!group \|\| !group->checkEntry(index.column(), rowNumberInGroup(index.row()))) {
		483	return KisSwatch();
		484	}
		485	return group->getEntry(index.column(), rowNumberInGroup(index.row()));
		486	}
		487
		488	int KisPaletteModel::groupNameRowForRow(int rowInModel) const
		489	{
		490	return rowInModel - rowNumberInGroup(rowInModel) - 1;
		491	}
Context not available.