Subversion Repositories Scribus

Rev

Rev 13809 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
13809 pierre 1
/***************************************************************************
2
 *   Copyright (C) 2009 by Pierre Marchand                                 *
3
 *   pierre@oep-h.com                                                      *
4
 *                                                                         *
5
 *   This program is free software; you can redistribute it and/or modify  *
6
 *   it under the terms of the GNU General Public License as published by  *
7
 *   the Free Software Foundation; either version 2 of the License, or     *
8
 *   (at your option) any later version.                                   *
9
 *                                                                         *
10
 *   This program is distributed in the hope that it will be useful,       *
11
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13
 *   GNU General Public License for more details.                          *
14
 *                                                                         *
15
 *   You should have received a copy of the GNU General Public License     *
16
 *   along with this program; if not, write to the                         *
17
 *   Free Software Foundation, Inc.,                                       *
18122 mrdocs 18
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
13809 pierre 19
 ***************************************************************************/
20
 
21
 
22
#include "openpalettemodel.h"
23
#include "openpalettemanager.h"
24
 
25
#include <QStringList>
26
 
27
OpenPaletteModel::OpenPaletteModel( QObject * parent )
28
                :QAbstractItemModel(parent)
29
{
30
        OpenPaletteManager::subChanges(this, SLOT(paletteChanged()));
31
}
32
 
33
QModelIndex OpenPaletteModel::index ( int row, int column, const QModelIndex & parent ) const
34
{
35
        return createIndex(row, column, parent.isValid() ? parent.row() : 0xFFFF);
36
}
37
 
38
QModelIndex OpenPaletteModel::parent ( const QModelIndex & index ) const
39
{
40
        if(index.isValid())
41
        {
42
                if(index.internalId() != 0xFFFF)
43
                        return createIndex(index.internalId() , 0,  0xFFFF);
44
        }
45
        return QModelIndex();
46
}
47
 
48
Qt::ItemFlags OpenPaletteModel::flags ( const QModelIndex & index ) const
49
{
50
        if(isTopIndex(index))
51
        {
52
                if(index.column() == 0)
53
                {
54
                        return Qt::ItemIsEnabled | Qt::ItemIsEditable;
55
                }
56
                else if (index.column() == 1)
57
                {
58
                        return Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
59
                }
60
        }
61
        return Qt::ItemIsEnabled;
62
}
63
 
64
QVariant OpenPaletteModel::data ( const QModelIndex & index, int role ) const
65
{
66
        if(!index.isValid())
67
                return QVariant();
68
        if(index.column() == 0)
69
        {
70
                // palette name
71
                if(isTopIndex(index))
72
                {
73
                        if(role == Qt::DisplayRole)
74
                        {
75
                                if(index.row() < OpenPaletteManager::count())
76
                                        return OpenPaletteManager::title(index.row());
77
                        }
78
                        return QVariant();
79
                }
80
 
81
                // setter name
82
                if(role == Qt::DisplayRole)
83
                {
84
                        if(index.internalId() < OpenPaletteManager::count())
85
                        {
86
                                QStringList pList( OpenPaletteManager::items(index.internalId()) );
87
                                if(index.row() < pList.count())
88
                                        return pList.at(index.row());
89
                        }
90
                }
91
        }
92
        else if(index.column() == 1)
93
        {
94
                if( isTopIndex(index) && role == Qt::CheckStateRole )
95
                {
96
                        if(OpenPaletteManager::paletteProperty(index.row(), QString::fromAscii("visible")).toBool())
97
                                return Qt::Checked;
98
                        return Qt::Unchecked;
99
                }
100
        }
101
        return QVariant();
102
}
103
 
104
QVariant OpenPaletteModel::headerData ( int section, Qt::Orientation orientation, int role ) const
105
{
106
        if(role == Qt::DisplayRole && orientation == Qt::Horizontal)
107
        {
108
                if(section == 0)
109
                        return tr("Elements");
110
                else if( section == 2)
111
                        return tr("Visible");
112
        }
113
        return QVariant();
114
}
115
 
116
 
117
int OpenPaletteModel::rowCount ( const QModelIndex & parent ) const
118
{
119
        if(!parent.isValid()) // root
120
                return OpenPaletteManager::count();
121
        else
122
        {
123
                if(parent.internalId() != 0xFFFF) // its a child item
124
                {
125
                        return 0;
126
                }
127
                else // a top level item
128
                {
129
                        if(parent.row() < OpenPaletteManager::count())
130
                        {
131
                                return OpenPaletteManager::items(parent.row()).count();
132
                        }
133
                }
134
        }
135
        return 0;
136
}
137
 
138
int OpenPaletteModel::columnCount ( const QModelIndex & parent ) const
139
{
140
        return 2;
141
}
142
 
143
bool OpenPaletteModel::setData(const QModelIndex & index, const QVariant & value, int role)
144
{
145
        if (isTopIndex(index))
146
                {
147
                if( index.column() == 0
148
                && (role == Qt::EditRole))
149
                {
150
                        bool ret = OpenPaletteManager::paletteProperty(index.row(), QString::fromAscii("windowTitle") , value);
151
                        if(ret)
152
                        {
153
                                emit dataChanged(index, index);
154
                        }
155
                        return ret;
156
                }
157
                else if( index.column() == 1
158
                && (role == Qt::CheckStateRole))
159
                {
160
                        bool ret = OpenPaletteManager::paletteProperty(index.row(), QString::fromAscii("visible") , value);
161
                        if(ret)
162
                        {
163
                                emit dataChanged(index, index);
164
                        }
165
                        return ret;
166
                }
167
        }
168
        return false;
169
 
170
}
171
 
172
bool OpenPaletteModel::isTopIndex(const QModelIndex & index) const
173
{
174
        if(index.isValid()
175
                && (!index.parent().isValid()))
176
        {
177
                return true;
178
        }
179
        return false;
180
}
181
 
182
void OpenPaletteModel::paletteChanged()
183
{
184
        emit layoutChanged();
185
}