studio/src/plugins/gui_editor/expression_node.cpp

   1 // Ryzom Core Studio - GUI Editor Plugin
   2 //
   3 // Copyright (C) 2010-2014  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   4 //
   5 // This program is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU Affero General Public License as
   7 // published by the Free Software Foundation, either version 3 of the
   8 // License, or (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 Affero General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Affero General Public License
  16 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 #include "expression_node.h"
  20 #include "expression_link.h"
  21 #include <QPainter>
  22 #include <QStyleOption>
  23
  24 struct NodeSlotInfo
  25 {
  26         // top-left
  27         QPoint tl;
  28
  29         // text top-left
  30         QPoint ttl;
  31
  32         // The text displayed
  33         QString text;
  34
  35         // text width
  36         qreal tw;
  37
  38         // text height
  39         qreal th;
  40
  41         // width-height of the box
  42         qreal wh;
  43 };
  44
  45 class NodeSlot
  46 {
  47 public:
  48         NodeSlot( const NodeSlotInfo &info )
  49         {
  50                 m_info = info;
  51         }
  52
  53         ~NodeSlot()
  54         {
  55         }
  56
  57         QPointF pos() const{
  58                 QPointF p;
  59                 p.setX( m_info.tl.x() + m_info.wh / 2.0 );
  60                 p.setY( m_info.tl.y() + m_info.wh / 2.0 );
  61
  62                 return p;
  63         }
  64
  65         void paint( QPainter *painter )
  66         {
  67                 QBrush boxBrush;
  68                 QPen p;
  69
  70                 boxBrush.setColor( Qt::black );
  71                 boxBrush.setStyle( Qt::SolidPattern );
  72                 p.setColor( Qt::black );
  73                 painter->setPen( p );
  74
  75                 QRectF box;
  76                 QRectF tbox;
  77
  78                 box.setTopLeft( m_info.tl );
  79                 box.setHeight( m_info.wh );
  80                 box.setWidth( m_info.wh );
  81
  82                 painter->fillRect( box, boxBrush );
  83
  84                 tbox.setTopLeft( m_info.ttl );
  85                 tbox.setHeight( m_info.th );
  86                 tbox.setWidth( m_info.tw );
  87
  88                 painter->drawText( tbox, Qt::AlignRight, m_info.text );
  89         }
  90
  91         QString text() const{ return m_info.text; }
  92         void setText( const QString &text ){ m_info.text = text; }
  93
  94 private:
  95         NodeSlotInfo m_info;
  96 };
  97
  98
  99
 100 ExpressionNode::ExpressionNode( const QString &name, int slotCount, QGraphicsItem *parent ) :
 101 QGraphicsItem( parent )
 102 {
 103         setFlags( QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemSendsScenePositionChanges );
 104
 105         m_w = 100;
 106         m_h = 100;
 107         m_hh = 20.0;
 108
 109         m_variable = false;
 110         m_isValue = false;
 111         m_isRoot = false;
 112
 113         m_name = name;
 114
 115         if( slotCount > 3 )
 116                 m_h = m_h + 20.0 * ( slotCount - 3 );
 117
 118         createSlots( slotCount );
 119 }
 120
 121 ExpressionNode::~ExpressionNode()
 122 {
 123         clearLinks();
 124         clearSlots();
 125 }
 126
 127 QRectF ExpressionNode::boundingRect() const
 128 {
 129         return QRectF( 0, 0, m_w, m_h );
 130 }
 131
 132 void ExpressionNode::paint( QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget )
 133 {
 134         QBrush br;
 135         QBrush boxBrush;
 136         QPen p;
 137         QColor c;
 138
 139         QRectF rect = boundingRect();
 140         QRectF header = rect;
 141         header.setHeight( m_hh );
 142
 143         // Draw filled rectangle, header
 144         if( !m_isRoot )
 145         {
 146                 c.setRed( 44 );
 147                 c.setGreen( 169 );
 148                 c.setBlue( 232 );
 149         }
 150         else
 151         {
 152                 c.setRed( 255 );
 153                 c.setGreen( 0 );
 154                 c.setBlue( 0 );
 155         }
 156         br.setColor( c );
 157         br.setStyle( Qt::SolidPattern );
 158         p.setColor( c );
 159         painter->setPen( p );
 160         painter->fillRect( header, br );
 161
 162         // Draw header text
 163         p.setColor( Qt::black );
 164         painter->setPen( p );
 165         painter->drawText( header, Qt::AlignCenter, m_name );
 166
 167         // Draw value if applicable
 168         if( m_isValue )
 169         {
 170                 QRectF vbox;
 171                 vbox.setTopLeft( QPoint( 0.0, 20.0 ) );
 172                 vbox.setWidth( header.width() );
 173                 vbox.setHeight( header.height() );
 174                 QPen vpen;
 175                 vpen.setColor( Qt::red );
 176                 painter->setPen( vpen );
 177                 painter->drawText( vbox, Qt::AlignCenter, m_value );
 178                 painter->setPen( p );
 179         }
 180
 181         if( option->state & QStyle::State_Selected )
 182         {
 183                 p.setStyle( Qt::DotLine );
 184                 p.setColor( Qt::red );
 185         }
 186
 187         // Draw outline of the entire thing + header
 188         painter->setPen( p );
 189         painter->drawRect( rect );
 190         painter->drawRect( header );
 191
 192         paintSlots( painter );
 193 }
 194
 195
 196 QPointF ExpressionNode::slotPos( int slot ) const
 197 {
 198         const NodeSlot *s = m_slots[ slot ];
 199         QPointF sp = s->pos();
 200         QPointF mp = pos();
 201
 202         mp += sp;
 203         return mp;
 204 }
 205
 206 void ExpressionNode::changeSlotCount( int count )
 207 {
 208         clearSlots();
 209         clearLinks();
 210         m_links.clear();
 211
 212         if( count <= 3 )
 213                 m_h = 100.0;
 214         else
 215                 m_h = 100.0 + 20.0 * ( count - 3 );
 216
 217         createSlots( count );
 218
 219         update();
 220 }
 221
 222 void ExpressionNode::clearSlots()
 223 {
 224         qDeleteAll( m_slots );
 225         m_slots.clear();
 226 }
 227
 228 bool ExpressionNode::slotEmpty( int slot ) const
 229 {
 230         if( m_links[ 0 ] == NULL )
 231                 return true;
 232         else
 233                 return false;
 234 }
 235
 236 void ExpressionNode::getSlots( QList< SlotInfo > &l )
 237 {
 238         SlotInfo info;
 239
 240         for( int i = 0; i < m_slots.count(); i++ )
 241         {
 242                 if( m_links[ i ] != NULL )
 243                         continue;
 244
 245                 info.name = m_slots[ i ]->text();
 246                 info.slot = i;
 247                 l.push_back( info );
 248         }
 249 }
 250
 251 void ExpressionNode::setLink( ExpressionLink *link, int slot )
 252 {
 253         m_links[ slot ] = link;
 254 }
 255
 256 ExpressionLink* ExpressionNode::link( int slot ) const
 257 {
 258         return m_links[ slot ];
 259 }
 260
 261 void ExpressionNode::setSlotNames( const QList< QString > &l )
 262 {
 263         int c = l.count();
 264         for( int i = 0; i < c; i++ )
 265         {
 266                 // "Out" slot is at position 0, so set the names with an offset of 1
 267                 m_slots[ i + 1 ]->setText( l[ i ] );
 268         }
 269 }
 270
 271 void ExpressionNode::setValue( const QString &value )
 272 {
 273         m_value = value;
 274
 275         int c = m_value.count();
 276         if( c < 15 )
 277                 m_w = 100.0;
 278         else
 279                 m_w = m_w + ( 100.0 / 15.0 ) * ( c - 15.0 );
 280
 281         update();
 282 }
 283
 284 void ExpressionNode::setRoot( bool b )
 285 {
 286         m_isRoot = b;
 287         update();
 288 }
 289
 290 QString ExpressionNode::build() const
 291 {
 292         QString result;
 293
 294         if( isValue() )
 295                 return m_value;
 296
 297         QStringList l = m_name.split( ' ' );
 298         result = l[ 0 ];
 299
 300         int c = m_links.count();
 301         if( c == 1 )
 302         {
 303                 result += "()";
 304                 return result;
 305         }
 306
 307         result += "( ";
 308
 309         for( int i = 1; i < c; i++ )
 310         {
 311                 ExpressionLink *link = m_links[ i ];
 312                 if( link == NULL )
 313                         continue;
 314
 315                 ExpressionNode *node = NULL;
 316
 317                 if( link->from() == this )
 318                         node = link->to();
 319                 else
 320                         node = link->from();
 321
 322                 result += node->build();
 323
 324                 if( i != ( c - 1 ) )
 325                         result += ", ";
 326         }
 327
 328         result += " )";
 329         return result;
 330 }
 331
 332 QVariant ExpressionNode::itemChange( GraphicsItemChange change, const QVariant &value )
 333 {
 334         if( change == ItemScenePositionHasChanged )
 335         {
 336                 onNodeMove();
 337         }
 338
 339         return QGraphicsItem::itemChange( change, value );
 340 }
 341
 342 void ExpressionNode::onNodeMove()
 343 {
 344         for( int i = 0; i < m_links.count(); i++ )
 345         {
 346                 ExpressionLink *link = m_links[ i ];
 347                 if( link == NULL )
 348                         continue;
 349
 350                 link->nodeMoved();
 351         }
 352 }
 353
 354 void ExpressionNode::createSlots( int count)
 355 {
 356         // Out nodes
 357         m_links.push_back( NULL );
 358
 359         for( int i = 0; i < count; i++ )
 360                 m_links.push_back( NULL );
 361
 362         // First create the "Out" slot
 363         NodeSlotInfo info;
 364         info.tw = 25.0;
 365         info.th = 12.0;
 366         info.wh = 10.0;
 367
 368         qreal x = 0.0;
 369         qreal y = m_h * 0.5;
 370         qreal tx = info.wh;
 371         qreal ty = m_h * 0.5 - 2;
 372
 373         info.tl = QPoint( x, y );
 374         info.ttl = QPoint( tx, ty );
 375         info.text = "Out";
 376
 377         m_slots.push_back( new NodeSlot( info ) );
 378
 379         // Then the rest of them
 380         for( int i = 0; i < count; i++ )
 381         {
 382                 x = m_w - info.wh;
 383                 y = 30 + i * 20.0;
 384                 tx = x - 5 - info.tw;
 385                 ty = y - 2;
 386
 387                 info.tl = QPoint( x, y );
 388                 info.ttl = QPoint( tx, ty );
 389                 info.text = QString( 'A' + i );
 390
 391                 m_slots.push_back( new NodeSlot( info ) );
 392         }
 393 }
 394
 395 void ExpressionNode::paintSlots( QPainter *painter )
 396 {
 397         for( int i = 0; i < m_slots.count(); i++ )
 398         {
 399                 NodeSlot *slot = m_slots[ i ];
 400                 slot->paint( painter );
 401         }
 402 }
 403
 404
 405 void ExpressionNode::clearLinks()
 406 {
 407         for( int i = 0; i < m_links.count(); i++ )
 408         {
 409                 ExpressionLink *link = m_links[ i ];
 410                 if( link == NULL )
 411                         continue;
 412
 413                 link->unlink();
 414         }
 415 }
 416