~scottydelicious666/brewtarget/brewtarget

« back to all changes in this revision

Viewing changes to FermentableTableModel.cpp

  • Committer: Philip Greggory Lee
  • Date: 2009-08-23 16:53:43 UTC
  • Revision ID: git-v1:f8d1a25135bd92f06c46c562293800e4faa42c61
Made a src/ and ui/ directory and moved everything.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*
2
 
 * FermentableTableModel.cpp is part of Brewtarget, and is Copyright Philip G. Lee
3
 
 * (rocketman768@gmail.com), 2009.
4
 
 *
5
 
 * Brewtarget 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 3 of the License, or
8
 
 * (at your option) any later version.
9
 
 
10
 
 * Brewtarget 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, see <http://www.gnu.org/licenses/>.
17
 
 */
18
 
 
19
 
#include <QAbstractTableModel>
20
 
#include <QAbstractItemModel>
21
 
#include <QAbstractItemView>
22
 
#include <QWidget>
23
 
#include <QModelIndex>
24
 
#include <QVariant>
25
 
#include <QCheckBox>
26
 
#include <QItemEditorFactory>
27
 
#include <QStyle>
28
 
#include <QRect>
29
 
 
30
 
#include "brewtarget.h"
31
 
#include <Qt>
32
 
#include <QSize>
33
 
#include <QComboBox>
34
 
#include <QLineEdit>
35
 
 
36
 
#include <vector>
37
 
#include <QString>
38
 
#include <vector>
39
 
#include <iostream>
40
 
#include "observable.h"
41
 
#include "fermentable.h"
42
 
#include "FermentableTableModel.h"
43
 
#include "unit.h"
44
 
 
45
 
//=====================CLASS FermentableTableModel==============================
46
 
FermentableTableModel::FermentableTableModel(FermentableTableWidget* parent)
47
 
: QAbstractTableModel(parent), MultipleObserver()
48
 
{
49
 
   fermObs.clear();
50
 
   parentTableWidget = parent;
51
 
   
52
 
   totalFermMass_kg = 0;
53
 
   displayPercentages = false;
54
 
}
55
 
 
56
 
void FermentableTableModel::addFermentable(Fermentable* ferm)
57
 
{
58
 
   std::vector<Fermentable*>::iterator iter;
59
 
   
60
 
   //Check to see if it's already in the list
61
 
   for( iter=fermObs.begin(); iter != fermObs.end(); iter++ )
62
 
      if( *iter == ferm )
63
 
         return;
64
 
   
65
 
   fermObs.push_back(ferm);
66
 
   addObserved(ferm);
67
 
   totalFermMass_kg += ferm->getAmount_kg();
68
 
   reset(); // Tell everybody that the table has changed.
69
 
   
70
 
   if(parentTableWidget)
71
 
   {
72
 
      parentTableWidget->resizeColumnsToContents();
73
 
      parentTableWidget->resizeRowsToContents();
74
 
   }
75
 
}
76
 
 
77
 
bool FermentableTableModel::removeFermentable(Fermentable* ferm)
78
 
{
79
 
   std::vector<Fermentable*>::iterator iter;
80
 
   
81
 
   for( iter=fermObs.begin(); iter != fermObs.end(); iter++ )
82
 
      if( *iter == ferm )
83
 
      {
84
 
         fermObs.erase(iter);
85
 
         removeObserved(ferm);
86
 
         totalFermMass_kg -= ferm->getAmount_kg();
87
 
         reset(); // Tell everybody the table has changed.
88
 
         
89
 
         if(parentTableWidget)
90
 
         {
91
 
            parentTableWidget->resizeColumnsToContents();
92
 
            parentTableWidget->resizeRowsToContents();
93
 
         }
94
 
         
95
 
         return true;
96
 
      }
97
 
   
98
 
   return false;
99
 
}
100
 
 
101
 
void FermentableTableModel::removeAll()
102
 
{
103
 
   unsigned int i;
104
 
 
105
 
   for( i = 0; i < fermObs.size(); ++i )
106
 
      removeObserved(fermObs[i]);
107
 
 
108
 
   fermObs.clear();
109
 
   totalFermMass_kg = 0;
110
 
   reset();
111
 
}
112
 
 
113
 
void FermentableTableModel::updateTotalGrains()
114
 
{
115
 
   unsigned int i, size;
116
 
   
117
 
   totalFermMass_kg = 0;
118
 
   
119
 
   size = fermObs.size();
120
 
   for( i = 0; i < size; ++i )
121
 
      totalFermMass_kg += fermObs[i]->getAmount_kg();
122
 
}
123
 
 
124
 
void FermentableTableModel::setDisplayPercentages(bool var)
125
 
{
126
 
   displayPercentages = var;
127
 
}
128
 
 
129
 
 
130
 
void FermentableTableModel::notify(Observable* notifier, QVariant info)
131
 
{
132
 
   int i;
133
 
   
134
 
   // Find the notifier in the list
135
 
   for( i = 0; i < (int)fermObs.size(); ++i )
136
 
   {
137
 
      if( notifier == fermObs[i] )
138
 
      {
139
 
         /*
140
 
         emit dataChanged( QAbstractItemModel::createIndex(i, 0),
141
 
                           QAbstractItemModel::createIndex(i, FERMNUMCOLS));
142
 
          */
143
 
         updateTotalGrains();
144
 
         reset();
145
 
         break;
146
 
      }
147
 
   }
148
 
}
149
 
 
150
 
int FermentableTableModel::rowCount(const QModelIndex& /*parent*/) const
151
 
{
152
 
   return fermObs.size();
153
 
}
154
 
 
155
 
int FermentableTableModel::columnCount(const QModelIndex& /*parent*/) const
156
 
{
157
 
   return FERMNUMCOLS;
158
 
}
159
 
 
160
 
QVariant FermentableTableModel::data( const QModelIndex& index, int role ) const
161
 
{
162
 
   Fermentable* row;
163
 
   
164
 
   // Ensure the row is ok.
165
 
   if( index.row() >= (int)fermObs.size() )
166
 
   {
167
 
      std::cerr << "Bad model index. row = " << index.row() << std::endl;
168
 
      return QVariant();
169
 
   }
170
 
   else
171
 
      row = fermObs[index.row()];
172
 
   
173
 
   switch( index.column() )
174
 
   {
175
 
      case FERMNAMECOL:
176
 
         if( role == Qt::DisplayRole )
177
 
            return QVariant(row->getName().c_str());
178
 
         else
179
 
            return QVariant();
180
 
      case FERMTYPECOL:
181
 
         if( role == Qt::DisplayRole )
182
 
            return QVariant(row->getType().c_str());
183
 
         else
184
 
            return QVariant();
185
 
      case FERMAMOUNTCOL:
186
 
         if( role == Qt::DisplayRole )
187
 
            return QVariant( Brewtarget::displayAmount(row->getAmount_kg(), Units::kilograms) );
188
 
         else
189
 
            return QVariant();
190
 
      case FERMISMASHEDCOL:
191
 
         if( role == Qt::CheckStateRole )
192
 
            return QVariant( row->getIsMashed() ? Qt::Checked : Qt::Unchecked);
193
 
         else if( role == Qt::DisplayRole )
194
 
            return row->getIsMashed() ? QString("Mashed") : QString ("Not mashed");
195
 
         else
196
 
            return QVariant();
197
 
      case FERMYIELDCOL:
198
 
         if( role == Qt::DisplayRole )
199
 
            return QVariant( Brewtarget::displayAmount(row->getYield_pct(), 0) );
200
 
         else
201
 
            return QVariant();
202
 
      case FERMCOLORCOL:
203
 
         if( role == Qt::DisplayRole )
204
 
            return QVariant( Brewtarget::displayAmount(row->getColor_srm(), 0) );
205
 
         else
206
 
            return QVariant();
207
 
      default :
208
 
         std::cerr << "Bad column: " << index.column() << std::endl;
209
 
         return QVariant();
210
 
   }
211
 
}
212
 
 
213
 
QVariant FermentableTableModel::headerData( int section, Qt::Orientation orientation, int role ) const
214
 
{
215
 
   if( orientation == Qt::Horizontal && role == Qt::DisplayRole )
216
 
   {
217
 
      switch( section )
218
 
      {
219
 
         case FERMNAMECOL:
220
 
            return QVariant("Name");
221
 
         case FERMTYPECOL:
222
 
            return QVariant("Type");
223
 
         case FERMAMOUNTCOL:
224
 
            return QVariant("Amount");
225
 
         case FERMISMASHEDCOL:
226
 
            return QVariant("Mashed");
227
 
         case FERMYIELDCOL:
228
 
            return QVariant("Yield %");
229
 
         case FERMCOLORCOL:
230
 
            return QVariant("Color (SRM)");
231
 
         default:
232
 
            std::cerr << "Bad column: " << section << std::endl;
233
 
            return QVariant();
234
 
      }
235
 
   }
236
 
   else if( displayPercentages && orientation == Qt::Vertical && role == Qt::DisplayRole )
237
 
   {
238
 
      return QVariant( QString("%1\%").arg( (double)100.0 *fermObs[section]->getAmount_kg()/totalFermMass_kg, 0, 'f', 0 ) );
239
 
   }
240
 
   else
241
 
      return QVariant();
242
 
}
243
 
 
244
 
Qt::ItemFlags FermentableTableModel::flags(const QModelIndex& index ) const
245
 
{
246
 
   Qt::ItemFlags defaults = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
247
 
   
248
 
   if( index.column()  == FERMISMASHEDCOL )
249
 
      return (defaults | Qt::ItemIsUserCheckable);
250
 
   else
251
 
      return (defaults | Qt::ItemIsEditable);
252
 
}
253
 
 
254
 
bool FermentableTableModel::setData( const QModelIndex& index, const QVariant& value, int role )
255
 
{
256
 
   Fermentable* row;
257
 
   
258
 
   if( index.row() >= (int)fermObs.size() )
259
 
   {
260
 
      return false;
261
 
   }
262
 
   else
263
 
      row = fermObs[index.row()];
264
 
   
265
 
   switch( index.column() )
266
 
   {
267
 
      case FERMNAMECOL:
268
 
         if( value.canConvert(QVariant::String))
269
 
         {
270
 
            row->setName(value.toString().toStdString());
271
 
            return true;
272
 
         }
273
 
         else
274
 
            return false;
275
 
      case FERMTYPECOL:
276
 
         if( value.canConvert(QVariant::String) )
277
 
         {
278
 
            row->setType(value.toString().toStdString());
279
 
            return true;
280
 
         }
281
 
         else
282
 
            return false;
283
 
      case FERMAMOUNTCOL:
284
 
         if( value.canConvert(QVariant::String) )
285
 
         {
286
 
            row->setAmount_kg( Unit::qstringToSI(value.toString()) );
287
 
            return true;
288
 
         }
289
 
         else
290
 
            return false;
291
 
      case FERMISMASHEDCOL:
292
 
         if( role == Qt::CheckStateRole && value.canConvert(QVariant::Int) )
293
 
         {
294
 
            row->setIsMashed( ((Qt::CheckState)value.toInt()) == Qt::Checked );
295
 
            return true;
296
 
         }
297
 
         else
298
 
            return false;
299
 
      case FERMYIELDCOL:
300
 
         if( value.canConvert(QVariant::String) )
301
 
         {
302
 
            row->setYield_pct( Unit::qstringToSI(value.toString()) );
303
 
            return true;
304
 
         }
305
 
         else
306
 
            return false;
307
 
      case FERMCOLORCOL:
308
 
         if( value.canConvert(QVariant::String) )
309
 
         {
310
 
            row->setColor_srm( Unit::qstringToSI(value.toString()) );
311
 
            return true;
312
 
         }
313
 
         else
314
 
            return false;
315
 
      default:
316
 
         std::cerr << "Bad column: " << index.column() << std::endl;
317
 
         return false;
318
 
   }
319
 
}
320
 
 
321
 
Fermentable* FermentableTableModel::getFermentable(unsigned int i)
322
 
{
323
 
   return fermObs[i];
324
 
}
325
 
 
326
 
//======================CLASS FermentableItemDelegate===========================
327
 
 
328
 
FermentableItemDelegate::FermentableItemDelegate(QObject* parent)
329
 
        : QStyledItemDelegate(parent)
330
 
{
331
 
   //connect( this, SIGNAL(closeEditor(QWidget*, QAbstractItemDelegate::EndEditHint)), this, SLOT(destroyWidget(QWidget*, QAbstractItemDelegate::EndEditHint)) );
332
 
}
333
 
 
334
 
void FermentableItemDelegate::destroyWidget(QWidget* widget, QAbstractItemDelegate::EndEditHint hint)
335
 
{
336
 
   delete widget;
337
 
}
338
 
 
339
 
 
340
 
QWidget* FermentableItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
341
 
{
342
 
   if( index.column() == FERMTYPECOL )
343
 
   {
344
 
      QComboBox *box = new QComboBox(parent);
345
 
 
346
 
      box->addItem("Grain");
347
 
      box->addItem("Sugar");
348
 
      box->addItem("Extract");
349
 
      box->addItem("Dry Extract");
350
 
      box->addItem("Adjunct");
351
 
      box->setSizeAdjustPolicy(QComboBox::AdjustToContents);
352
 
      return box;
353
 
   }
354
 
   else if( index.column() == FERMISMASHEDCOL )
355
 
   {
356
 
      QCheckBox* box = new QCheckBox(parent);
357
 
      box->setFocusPolicy(Qt::StrongFocus);
358
 
      box->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
359
 
 
360
 
      /*
361
 
      QWidget* displayWidget = (((FermentableTableModel*)(index.model()))->parentTableWidget)->indexWidget(index);
362
 
      if( displayWidget != 0 )
363
 
         box->move(displayWidget->pos());
364
 
      ***Didn't work at all***/
365
 
      
366
 
      /*
367
 
      QRect rect = QStyle::alignedRect(Qt::LeftToRight, Qt::AlignLeft, box->sizeHint(), option.rect);
368
 
      std::cerr << "option.rect " << option.rect.x() << " " << option.rect.y() << " " << option.rect.width() << " " << option.rect.height() << std::endl;
369
 
      std::cerr << "rect " << rect.x() << " " << rect.y() << " " << rect.width() << " " << rect.height() << std::endl;
370
 
      box->move(rect.topRight());
371
 
      ***Didn't really do much either***/
372
 
      
373
 
      return box;
374
 
 
375
 
      //return QItemDelegate::createEditor(parent, option, index);
376
 
      //return itemEditorFactory()->createEditor(QVariant::Bool, parent);
377
 
   }
378
 
   else
379
 
      return new QLineEdit(parent);
380
 
}
381
 
 
382
 
void FermentableItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
383
 
{
384
 
   if( index.column() == FERMTYPECOL )
385
 
   {
386
 
      QComboBox* box = (QComboBox*)editor;
387
 
      QString text = index.model()->data(index, Qt::DisplayRole).toString();
388
 
      
389
 
      int index = box->findText(text);
390
 
      box->setCurrentIndex(index);
391
 
   }
392
 
   else if( index.column() == FERMISMASHEDCOL )
393
 
   {
394
 
      QCheckBox* checkBox = (QCheckBox*)editor;
395
 
      Qt::CheckState checkState = (Qt::CheckState)index.model()->data(index, Qt::CheckStateRole).toInt();
396
 
      
397
 
      checkBox->setCheckState( checkState );
398
 
   }
399
 
   else
400
 
   {
401
 
      QLineEdit* line = (QLineEdit*)editor;
402
 
      
403
 
      line->setText(index.model()->data(index, Qt::DisplayRole).toString());
404
 
   }
405
 
   
406
 
}
407
 
 
408
 
void FermentableItemDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
409
 
{
410
 
   if( index.column() == FERMTYPECOL )
411
 
   {
412
 
      QComboBox* box = (QComboBox*)editor;
413
 
      QString value = box->currentText();
414
 
      
415
 
      model->setData(index, value, Qt::EditRole);
416
 
   }
417
 
   else if( index.column() == FERMISMASHEDCOL )
418
 
   {
419
 
      QCheckBox* checkBox = (QCheckBox*)editor;
420
 
      bool checked = (checkBox->checkState() == Qt::Checked);
421
 
      
422
 
      model->setData(index, checked, Qt::EditRole);
423
 
   }
424
 
   else
425
 
   {
426
 
      QLineEdit* line = (QLineEdit*)editor;
427
 
      
428
 
      model->setData(index, line->text(), Qt::EditRole);
429
 
   }
430
 
}
431
 
 
432
 
/*
433
 
void FermentableItemDelegate::paint( QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index ) const
434
 
{
435
 
   if( index.column() == FERMISMASHEDCOL )
436
 
   {
437
 
      QItemDelegate::drawCheck(painter, option, option.rect, (Qt::CheckState)index.model()->data(index, Qt::CheckStateRole).toInt() );
438
 
   }
439
 
   else
440
 
   {
441
 
      QString str = index.model()->data(index, Qt::DisplayRole).toString();
442
 
      QItemDelegate::drawDisplay(painter, option, option.rect, str);
443
 
   }
444
 
}
445
 
*/
446
 
 
447
 
void FermentableItemDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const
448
 
{
449
 
   editor->setGeometry(option.rect);
450
 
}