studio/src/plugins/tile_editor/tile_item.cpp

   1 // Object Viewer Qt - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2011-2012  Matt RAYKOWSKI (sfb) <matt.raykowski@gmail.com>
   6 // Copyright (C) 2014  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 #include <QPixmap>
  22
  23 #include "tile_item.h"
  24
  25 #include <nel/misc/debug.h>
  26
  27 Node::Node() : m_parentItem(0)
  28 {
  29 }
  30
  31 Node::Node(const QVector<QVariant> &data, Node *parent)
  32 {
  33         m_parentItem = parent;
  34         m_itemData = data;
  35 }
  36
  37 Node::~Node()
  38 {
  39         qDeleteAll(m_childItems);
  40         m_childItems.clear();
  41 }
  42
  43 void Node::appendChild(Node *item)
  44 {
  45         item->setParent( this );
  46         m_childItems.append(item);
  47 }
  48
  49 Node *Node::child(int row)
  50 {
  51         //nlinfo("row %d and size %d", row, childItems.size());
  52         return m_childItems.value(row);
  53 }
  54
  55 int Node::childCount() const
  56 {
  57         return m_childItems.count();
  58 }
  59
  60 int Node::childNumber() const
  61 {
  62         if(m_parentItem)
  63                 return m_parentItem->m_childItems.indexOf(const_cast<Node*>(this));
  64         return 0;
  65 }
  66
  67 bool Node::insertChildren(int position, int count, int columns)
  68 {
  69         if(position<0 || position>m_childItems.size())
  70                 return false;
  71
  72         for(int row = 0; row < count; row++)
  73         {
  74                 QVector<QVariant> data(columns);
  75                 Node *item = new Node(data, this);
  76                 m_childItems.insert(position, item);
  77         }
  78
  79         return true;
  80 }
  81
  82 bool Node::removeChildren(int position, int count)
  83 {
  84         if(position<0 || position+count>m_childItems.size())
  85                 return false;
  86
  87         for(int row=0; row<count; row++)
  88                 delete m_childItems.takeAt(position);
  89
  90         return true;
  91 }
  92
  93 bool Node::insertColumns(int position, int columns)
  94 {
  95         if(position<0 || position > m_itemData.size())
  96                 return false;
  97
  98         for(int column=0; column<columns; column++)
  99                 m_itemData.insert(position, columns);
 100
 101         Q_FOREACH(Node *child, m_childItems)
 102                 child->insertColumns(position, columns);
 103
 104         return true;
 105 }
 106
 107 int Node::row() const
 108 {
 109         if(m_parentItem)
 110                 return m_parentItem->m_childItems.indexOf(const_cast<Node*>(this));
 111
 112         return 0;
 113 }
 114
 115 int Node::columnCount() const
 116 {
 117         return m_itemData.count();
 118 }
 119
 120 QVariant Node::data(int column, int role) const
 121 {
 122         if(role == Qt::DisplayRole ||
 123                 role == TileModel::TileFilenameIndexRole ||
 124                 role == TileModel::TileFilenameRole ||
 125                 role == TileModel::TileIndexRole)
 126                 return m_itemData.value(column);
 127         return QVariant();
 128 }
 129
 130 bool Node::setData(int column, const QVariant &value)
 131 {
 132         if(column < 0 || column >= m_itemData.size())
 133                 return false;
 134
 135         m_itemData[column] = value;
 136         return true;
 137 }
 138
 139 Node *Node::parent()
 140 {
 141         return m_parentItem;
 142 }
 143
 144 void Node::setParent(Node *parent)
 145 {
 146         m_parentItem = parent;
 147 }
 148
 149 void Node::appendRow(const QList<Node*> &items)
 150 {
 151         Q_FOREACH(Node *item, items)
 152                 appendRow(item);
 153 }
 154
 155 void Node::appendRow(Node *item)
 156 {
 157         item->setParent(this);
 158         m_childItems.append(item);
 159 }
 160
 161 void Node::swapRows( int a, int b )
 162 {
 163         Node *temp = m_childItems[ a ];
 164         m_childItems[ a ] = m_childItems[ b ];
 165         m_childItems[ b ] = temp;
 166 }
 167
 168 void Node::clear()
 169 {
 170         qDeleteAll( m_childItems );
 171         m_childItems.clear();
 172         m_itemData.clear();
 173 }
 174
 175 ///////////////////////////////////////////////////
 176
 177 TileSetNode::TileSetNode(QString tileSetName, Node *parent) : m_tileSetName(tileSetName)
 178 {
 179         m_parentItem = parent;
 180 }
 181
 182 TileSetNode::~TileSetNode()
 183 {
 184         qDeleteAll(m_childItems);
 185         m_childItems.clear();
 186 }
 187
 188 QVariant TileSetNode::data(int column, int role) const
 189 {
 190         if(role == Qt::DisplayRole ||
 191                 role == TileModel::TileFilenameIndexRole ||
 192                 role == TileModel::TileFilenameRole ||
 193                 role == TileModel::TileIndexRole)
 194                 return QVariant(m_tileSetName);
 195         return QVariant();
 196 }
 197
 198 int TileSetNode::columnCount() const
 199 {
 200         return 1;
 201 }
 202
 203 ///////////////////////////////////////////////////
 204
 205 TileTypeNode::TileTypeNode(TileConstants::TNodeTileType type, Node *parent) : m_nodeTileType(type)
 206 {
 207         m_parentItem = parent;
 208 }
 209
 210 TileTypeNode::~TileTypeNode()
 211 {
 212         qDeleteAll(m_childItems);
 213         m_childItems.clear();
 214 }
 215
 216 QVariant TileTypeNode::data(int column, int role) const
 217 {
 218         if(role == Qt::DisplayRole ||
 219                 role == TileModel::TileFilenameIndexRole ||
 220                 role == TileModel::TileFilenameRole ||
 221                 role == TileModel::TileIndexRole)
 222                 return QVariant(TileModel::getTileTypeName(m_nodeTileType));
 223         return QVariant();
 224
 225 }
 226
 227 int TileTypeNode::columnCount() const
 228 {
 229         return 1;
 230 }
 231
 232 TileConstants::TNodeTileType TileTypeNode::getTileType()
 233 {
 234         return m_nodeTileType;
 235 }
 236
 237 bool TileTypeNode::removeChildren( int position, int count )
 238 {
 239         bool ok = Node::removeChildren( position, count );
 240         if( !ok )
 241                 return false;
 242
 243         reindex();
 244
 245         return true;
 246 }
 247
 248 void TileTypeNode::reindex()
 249 {
 250         int i = 0;
 251
 252         QListIterator< Node* > itr( m_childItems );
 253         while( itr.hasNext() )
 254         {
 255                 TileItemNode *n = dynamic_cast< TileItemNode* >( itr.next() );
 256                 if( n == NULL )
 257                         continue;
 258
 259                 n->setId( i );
 260
 261                 i++;
 262         }
 263 }
 264
 265
 266 ///////////////////////////////////////////////////
 267
 268 class TileItemNodePvt
 269 {
 270 public:
 271
 272         TileItemNodePvt()
 273         {
 274         }
 275
 276         bool loadImage( TileConstants::TTileChannel channel, const QString &fn )
 277         {
 278                 if( fn.isEmpty() )
 279                 {
 280                         pixmaps[ channel ] = TileItemNodePvt::emptyPm();
 281                         return true;
 282                 }
 283
 284                 QPixmap temp;
 285                 bool b = temp.load( fn );
 286
 287                 if( !b )
 288                 {
 289                         return false;
 290                 }
 291
 292                 pixmaps[ channel ] = temp;
 293
 294                 return true;
 295         }
 296
 297         static bool loadEmptyImage()
 298         {
 299                 bool b = empty.load( ":/placeHolder/images/empty_image.png" );
 300                 if( !b )
 301                 {
 302                         empty = QPixmap();
 303                 }
 304
 305                 return b;
 306         }
 307
 308         void clearImage( TileConstants::TTileChannel channel )
 309         {
 310                 pixmaps[ channel ] = QPixmap();
 311         }
 312
 313         const QPixmap& pixMap( TileConstants::TTileChannel channel ) const{
 314                 return pixmaps[ channel ];
 315         }
 316
 317         static QPixmap& emptyPm(){ return empty; }
 318
 319 private:
 320         QPixmap pixmaps[ TileConstants::TileChannelCount ];
 321         static QPixmap empty;
 322
 323 };
 324
 325 QPixmap TileItemNodePvt::empty = QPixmap();
 326 TileConstants::TTileChannel TileItemNode::s_displayChannel = TileConstants::TileDiffuse;
 327
 328 TileItemNode::TileItemNode( TileConstants::TNodeTileType type, int tileId, Node *parent )
 329 {
 330         m_id = tileId;
 331         m_parentItem = parent;
 332         pvt = new TileItemNodePvt();
 333
 334         for( int i = 0; i < TileConstants::TileChannelCount; i++ )
 335         {
 336                 setTileFilename( TileConstants::TTileChannel( i ), "" );
 337         }
 338 }
 339
 340 TileItemNode::~TileItemNode()
 341 {
 342         delete pvt;
 343         pvt = NULL;
 344
 345         qDeleteAll(m_childItems);
 346 }
 347
 348 bool TileItemNode::setTileFilename(TileConstants::TTileChannel channel, QString filename)
 349 {
 350         bool b = pvt->loadImage( channel, filename );
 351         if( !b )
 352                 return false;
 353
 354         m_tileFilename[channel] = filename;
 355         return true;
 356 }
 357
 358 QString TileItemNode::getTileFilename(TileConstants::TTileChannel channel)
 359 {
 360         QMap< TileConstants::TTileChannel, QString >::const_iterator itr
 361                 = m_tileFilename.find( channel );
 362         if( itr == m_tileFilename.end() )
 363                 return "";
 364
 365         return itr.value();
 366 }
 367
 368 bool TileItemNode::loadEmptyPixmap()
 369 {
 370         return TileItemNodePvt::loadEmptyImage();
 371 }
 372
 373 QVariant TileItemNode::data(int column, int role) const
 374 {
 375         QString tileFilename = m_tileFilename[ TileItemNode::s_displayChannel ];
 376
 377         if(role == TileModel::TilePixmapRole || role == Qt::DecorationRole)
 378         {
 379                 TileTypeNode *parent = dynamic_cast<TileTypeNode*>(m_parentItem);
 380                 if(parent == NULL)
 381                         return QVariant();
 382
 383                 // Retrieve the target tile size.
 384                 uint32 tileSize = TileModel::getTileTypeSize(parent->getTileType());
 385
 386                 if(TileModel::CurrentZoomFactor == TileModel::TileZoom200)
 387                         tileSize *= 2;
 388                 else if(TileModel::CurrentZoomFactor == TileModel::TileZoom50)
 389                         tileSize /= 2;
 390
 391                 QPixmap pixmap = pvt->pixMap( TileItemNode::s_displayChannel );
 392
 393                 pixmap = pixmap.scaled(tileSize, tileSize);
 394
 395                 return pixmap;
 396         }
 397         else if(role == Qt::DisplayRole)
 398         {
 399                 return QVariant(tileFilename);
 400         }
 401         else if(role == TileModel::TileFilenameRole)
 402         {
 403                 return QVariant(tileFilename);
 404         }
 405         else if(role == TileModel::TileIndexRole)
 406         {
 407                 return QVariant("("+QString::number(m_id)+")");
 408         }
 409         else if(role == TileModel::TileFilenameIndexRole)
 410         {
 411                 return QVariant(tileFilename + " ("+QString::number(m_id)+")");
 412         }
 413
 414         return QVariant();
 415 }
 416
 417 int TileItemNode::columnCount() const
 418 {
 419         return 1;
 420 }
 421
 422 QVariant TileItemNode::pixmap( TileConstants::TTileChannel channel ) const
 423 {
 424         return pvt->pixMap( channel );
 425 }
 426