companion/src/modelslist.cpp

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include "modelslist.h"
  22
  23 TreeItem::TreeItem(const QVector<QVariant> & itemData):
  24   itemData(itemData),
  25   parentItem(NULL),
  26   categoryIndex(-1),
  27   modelIndex(-1),
  28   flags(0)
  29 {
  30 }
  31
  32 TreeItem::TreeItem(TreeItem * parent, int categoryIndex, int modelIndex):
  33   TreeItem(QVector<QVariant>(parent->columnCount()))
  34 {
  35   setParent(parent);
  36   setCategoryIndex(categoryIndex);
  37   setModelIndex(modelIndex);
  38 }
  39
  40 TreeItem::~TreeItem()
  41 {
  42   qDeleteAll(childItems);
  43 }
  44
  45 TreeItem * TreeItem::child(int number)
  46 {
  47   return childItems.value(number);
  48 }
  49
  50 int TreeItem::childCount() const
  51 {
  52   return childItems.count();
  53 }
  54
  55 int TreeItem::childNumber() const
  56 {
  57   if (parentItem)
  58     return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));
  59
  60   return 0;
  61 }
  62
  63 int TreeItem::columnCount() const
  64 {
  65   return itemData.count();
  66 }
  67
  68 QVariant TreeItem::data(int column) const
  69 {
  70   return itemData.value(column);
  71 }
  72
  73 TreeItem *TreeItem::insertChild(const int row, int categoryIndex, int modelIndex)
  74 {
  75   TreeItem * item = new TreeItem(this, categoryIndex, modelIndex);
  76   childItems.insert(row, item);
  77   return item;
  78 }
  79
  80 TreeItem * TreeItem::appendChild(int categoryIndex, int modelIndex)
  81 {
  82   return insertChild(childItems.size(), categoryIndex, modelIndex);
  83 }
  84
  85 bool TreeItem::removeChildren(int position, int count)
  86 {
  87   if (position < 0 || position + count > childItems.size())
  88     return false;
  89
  90   for (int row = 0; row < count; ++row)
  91     delete childItems.takeAt(position);
  92
  93   return true;
  94 }
  95
  96 bool TreeItem::insertChildren(int row, int count)
  97 {
  98   for (int i=0; i < count; ++i) {
  99     insertChild(row + i, -1, -1);
 100   }
 101   return true;
 102 }
 103
 104 bool TreeItem::setData(int column, const QVariant & value)
 105 {
 106   if (column < 0 || column >= itemData.size())
 107     return false;
 108
 109   itemData[column] = value;
 110   return true;
 111 }
 112
 113 void TreeItem::setFlag(const quint16 & flag, const bool on)
 114 {
 115   if (on)
 116     flags |= flag;
 117   else
 118     flags &= ~flag;
 119 }
 120
 121 bool TreeItem::isCategory() const
 122 {
 123   return (modelIndex < 0 && categoryIndex > -1);
 124 }
 125
 126 bool TreeItem::isModel() const
 127 {
 128   return (modelIndex > -1);
 129 }
 130
 131
 132 /*
 133  * TreeModel
 134 */
 135
 136 TreeModel::TreeModel(RadioData * radioData, QObject * parent):
 137   QAbstractItemModel(parent),
 138   radioData(radioData),
 139   availableEEpromSize(-1)
 140 {
 141   Board::Type board = getCurrentBoard();
 142   QVector<QVariant> labels;
 143   if (!getCurrentFirmware()->getCapability(Capability::HasModelCategories))
 144     labels << tr("Index");
 145   labels << tr("Name");
 146   if (!(IS_HORUS(board) || IS_SKY9X(board))) {
 147     labels << tr("Size");
 148   }
 149   rootItem = new TreeItem(labels);
 150   // uniqueId and version for drag/drop operations (see encodeHeaderData())
 151   mimeHeaderData.instanceId = QUuid::createUuid();
 152   mimeHeaderData.dataVersion = 1;
 153
 154   refresh();
 155   //connect(this, &QAbstractItemModel::rowsAboutToBeRemoved, this, &TreeModel::onRowsAboutToBeRemoved);
 156   connect(this, &QAbstractItemModel::rowsRemoved, this, &TreeModel::onRowsRemoved);
 157 }
 158
 159 TreeModel::~TreeModel()
 160 {
 161   delete rootItem;
 162 }
 163
 164 int TreeModel::columnCount(const QModelIndex & /* parent */) const
 165 {
 166   return rootItem->columnCount();
 167 }
 168
 169 QVariant TreeModel::data(const QModelIndex & index, int role) const
 170 {
 171   if (!index.isValid())
 172     return QVariant();
 173
 174   TreeItem * item = getItem(index);
 175
 176   if (role == Qt::DisplayRole || role == Qt::EditRole) {
 177     return item->data(index.column());
 178   }
 179
 180   if (role == Qt::FontRole && item->isModel() && item->getModelIndex() == (int)radioData->generalSettings.currModelIndex) {
 181     QFont font;
 182     font.setBold(true);
 183     return font;
 184   }
 185
 186   if (role == Qt::ForegroundRole && (item->getFlags() & TreeItem::MarkedForCut)) {
 187     return QPalette().brush(QPalette::Disabled, QPalette::Text);
 188   }
 189
 190   return QVariant();
 191 }
 192
 193 Qt::ItemFlags TreeModel::flags(const QModelIndex &index) const
 194 {
 195   Qt::ItemFlags f = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 196
 197   if (index.isValid()) {
 198     if (getItem(index)->isCategory())
 199       f |= Qt::ItemIsEditable;
 200     else
 201       f |= Qt::ItemIsDragEnabled;  // TODO drag/drop categories
 202   }
 203   f |= Qt::ItemIsDropEnabled;
 204
 205   //qDebug() << f;
 206   return f;
 207 }
 208
 209 QVariant TreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 210 {
 211   if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
 212     return rootItem->data(section);
 213
 214   return QVariant();
 215 }
 216
 217 QModelIndex TreeModel::index(int row, int column, const QModelIndex & parent) const
 218 {
 219   if (parent.isValid() && parent.column() != 0)
 220     return QModelIndex();
 221
 222   TreeItem * parentItem = getItem(parent);
 223   TreeItem * childItem = parentItem->child(row);
 224   if (childItem)
 225     return createIndex(row, column, childItem);
 226   else
 227     return QModelIndex();
 228 }
 229
 230 QModelIndex TreeModel::parent(const QModelIndex & index) const
 231 {
 232   if (!index.isValid())
 233     return QModelIndex();
 234
 235   TreeItem * childItem = getItem(index);
 236   TreeItem * parentItem = childItem->parent();
 237
 238   if (parentItem == rootItem)
 239     return QModelIndex();
 240
 241   return createIndex(parentItem->childNumber(), 0, parentItem);
 242 }
 243
 244 bool TreeModel::removeRows(int position, int rows, const QModelIndex & parent)
 245 {
 246   TreeItem * parentItem = getItem(parent);
 247   if (!parentItem)
 248     return false;
 249
 250   bool success = true;
 251   if (position >= 0 && rows > 0) {
 252     beginRemoveRows(parent, position, position + rows - 1);
 253     success = parentItem->removeChildren(position, rows);
 254     endRemoveRows();
 255   }
 256
 257   return success;
 258 }
 259
 260 /* unused but possibly useful in future
 261 bool TreeModel::insertRows(int row, int count, const QModelIndex & parent)
 262 {
 263   TreeItem * parentItem = getItem(parent);
 264   if (!parentItem)
 265     return false;
 266
 267   bool success = true;
 268   if (row >= 0 && count > 0) {
 269     beginInsertRows(parent, row, row + count - 1);
 270     success = parentItem->insertChildren(row, count);
 271     endInsertRows();
 272   }
 273
 274   return success;
 275 }  */
 276
 277 int TreeModel::rowCount(const QModelIndex &parent) const
 278 {
 279   TreeItem * parentItem = getItem(parent);
 280   return parentItem->childCount();
 281 }
 282
 283 bool TreeModel::setData(const QModelIndex & index, const QVariant & value, int role)
 284 {
 285   if (role != Qt::EditRole)
 286     return false;
 287
 288   if (!index.isValid())
 289     return false;
 290
 291   TreeItem * item = getItem(index);
 292   bool result = item->setData(index.column(), value);
 293
 294   if (result) {
 295     emit dataChanged(index, index);
 296   }
 297
 298   return result;
 299 }
 300
 301 QStringList TreeModel::mimeTypes() const
 302 {
 303   QStringList types;
 304   types << "application/x-companion-modeldata";
 305   types << "application/x-companion-generaldata";
 306   //type << "application/x-companion-radiodata-header";  // supported but not advertised, must be in conjunction with one of the above
 307   return types;
 308 }
 309
 310 Qt::DropActions TreeModel::supportedDropActions() const
 311 {
 312   return Qt::CopyAction | Qt::MoveAction;
 313 }
 314
 315 Qt::DropActions TreeModel::supportedDragActions() const
 316 {
 317   return Qt::CopyAction | Qt::MoveAction;
 318 }
 319
 320 // This method encodes all the data on default drag operation, including general radio settings. This is useful for eg. Compare dialog/model printer.
 321 QMimeData * TreeModel::mimeData(const QModelIndexList & indexes) const
 322 {
 323   QMimeData * mimeData = new QMimeData();
 324   getModelsMimeData(indexes, mimeData);
 325   getGeneralMimeData(mimeData);
 326   getHeaderMimeData(mimeData);
 327   return mimeData;
 328 }
 329
 330 bool TreeModel::canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const
 331 {
 332   Q_UNUSED(action);
 333   //qDebug() << action << row << column << parent.row();
 334
 335   // we do not accept dropped general settings right now (user must copy/paste those)
 336   if (hasHeaderMimeData(data) && hasModelsMimeData(data) && (row > -1 || parent.isValid()))
 337     return true;
 338
 339   return false;
 340 }
 341
 342 bool TreeModel::dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent)
 343 {
 344   if (!canDropMimeData(data, action, row, column, parent))
 345     return false;
 346
 347   if (action == Qt::IgnoreAction)
 348     return true;
 349
 350   QModelIndex idx;
 351   bool isInsert = false;
 352   if (row > -1) {
 353     // dropped between rows (insert)
 354     isInsert = true;
 355     idx = index(row, column, parent);
 356   }
 357   else if (parent.isValid()) {
 358     // was dropped on a row (overwrite)
 359     idx = parent;
 360   }
 361   else {
 362     // dropped who knows where, (shouldn't be here though due check in canDropMimeData())
 363     return false;
 364   }
 365   //qDebug() << action << row << column << parent.row() << idx << idx.row() << hasOwnMimeData(data);
 366
 367   // Force drops from other file windows to be copy actions because we don't want to delete our models.
 368   if (action == Qt::MoveAction && !hasOwnMimeData(data))
 369     action = Qt::CopyAction;
 370
 371   // canDropMimeData() only accepts models
 372   emit modelsDropped(data, idx, isInsert, (action == Qt::MoveAction));
 373
 374   return true;
 375 }
 376
 377 QMimeData *TreeModel::getModelsMimeData(const QModelIndexList & indexes, QMimeData * mimeData) const
 378 {
 379   if (!mimeData)
 380     mimeData = new QMimeData();
 381   QByteArray mData;
 382   encodeModelsData(indexes, &mData);
 383   mimeData->setData("application/x-companion-modeldata", mData);
 384   return mimeData;
 385 }
 386
 387 QMimeData *TreeModel::getGeneralMimeData(QMimeData * mimeData) const
 388 {
 389   if (!mimeData)
 390     mimeData = new QMimeData();
 391   QByteArray mData;
 392   encodeGeneralData(&mData);
 393   mimeData->setData("application/x-companion-generaldata", mData);
 394   return mimeData;
 395 }
 396
 397 QMimeData *TreeModel::getHeaderMimeData(QMimeData * mimeData) const
 398 {
 399   if (!mimeData)
 400     mimeData = new QMimeData();
 401   QByteArray mData;
 402   encodeHeaderData(&mData);
 403   mimeData->setData("application/x-companion-radiodata-header", mData);
 404   return mimeData;
 405 }
 406
 407 QUuid TreeModel::getMimeDataSourceId(const QMimeData * mimeData) const
 408 {
 409   MimeHeaderData header;
 410   decodeHeaderData(mimeData, &header);
 411   return header.instanceId;
 412 }
 413
 414 bool TreeModel::hasSupportedMimeData(const QMimeData * mimeData) const
 415 {
 416   foreach (const QString & mtype, mimeTypes()) {
 417     if (mimeData->hasFormat(mtype))
 418       return true;
 419   }
 420   return false;
 421 }
 422
 423 bool TreeModel::hasModelsMimeData(const QMimeData * mimeData) const
 424 {
 425   return mimeData->hasFormat("application/x-companion-modeldata");
 426 }
 427
 428 bool TreeModel::hasGenralMimeData(const QMimeData * mimeData) const
 429 {
 430   return mimeData->hasFormat("application/x-companion-generaldata");
 431 }
 432
 433 bool TreeModel::hasHeaderMimeData(const QMimeData * mimeData) const
 434 {
 435   return mimeData->hasFormat("application/x-companion-radiodata-header");
 436 }
 437
 438 // returns true if mime data origin was this data model (vs. from another file window)
 439 bool TreeModel::hasOwnMimeData(const QMimeData * mimeData) const
 440 {
 441   return (getMimeDataSourceId(mimeData) == mimeHeaderData.instanceId);
 442 }
 443
 444 void TreeModel::encodeModelsData(const QModelIndexList & indexes, QByteArray * data) const
 445 {
 446   foreach (const QModelIndex &index, indexes) {
 447     if (index.isValid() && index.column() == 0) {
 448       if (!getItem(index)->isCategory()) {  // TODO: encode categoreis also
 449         data->append('M');
 450         data->append((char *)&radioData->models[getModelIndex(index)], sizeof(ModelData));
 451       }
 452     }
 453   }
 454 }
 455
 456 void TreeModel::encodeGeneralData(QByteArray * data) const
 457 {
 458   data->append('G');
 459   data->append((char *)&radioData->generalSettings, sizeof(GeneralSettings));
 460 }
 461
 462 void TreeModel::encodeHeaderData(QByteArray * data) const
 463 {
 464   // We use a unique ID representing this TreeModel instance (a unique file).
 465   // This can be used eg. to detect cross-file drop operations.
 466   QDataStream stream(data, QIODevice::WriteOnly);
 467   stream << mimeHeaderData.dataVersion;
 468   stream << mimeHeaderData.instanceId;
 469 }
 470
 471 // static
 472 bool TreeModel::decodeHeaderData(const QMimeData * mimeData, MimeHeaderData * header)
 473 {
 474   if (header && mimeData->hasFormat("application/x-companion-radiodata-header")) {
 475     QByteArray data = mimeData->data("application/x-companion-radiodata-header");
 476     QDataStream stream(&data, QIODevice::ReadOnly);
 477     stream >> header->dataVersion >> header->instanceId;
 478     return true;
 479   }
 480   return false;
 481 }
 482
 483 // static
 484 bool TreeModel::decodeMimeData(const QMimeData * mimeData, QVector<ModelData> * models, GeneralSettings * gs, bool * hasGenSet)
 485 {
 486   bool ret = false;
 487   char * gData;
 488
 489   if (hasGenSet)
 490     *hasGenSet = false;
 491
 492   if (models && mimeData->hasFormat("application/x-companion-modeldata")) {
 493     QByteArray mdlData = mimeData->data("application/x-companion-modeldata");
 494     gData = mdlData.data();
 495     int size = 0;
 496     while (size < mdlData.size()) {
 497       char c = *gData++;
 498       if (c != 'M')
 499         break;
 500       ModelData model(*((ModelData *)gData));
 501       models->append(model);
 502       gData += sizeof(ModelData);
 503       size += sizeof(ModelData) + 1;
 504       ret = true;
 505     }
 506   }
 507
 508   // General settings
 509   if (gs && mimeData->hasFormat("application/x-companion-generaldata")) {
 510     QByteArray genData = mimeData->data("application/x-companion-generaldata");
 511     gData = genData.data();
 512     char c = *gData++;
 513     if (c == 'G') {
 514       *gs = *((GeneralSettings *)gData);
 515       ret = true;
 516       if (hasGenSet)
 517         *hasGenSet = true;
 518     }
 519   }
 520
 521   return ret;
 522 }
 523
 524 // static
 525 int TreeModel::countModelsInMimeData(const QMimeData * mimeData)
 526 {
 527   int ret = 0;
 528   if (mimeData->hasFormat("application/x-companion-modeldata")) {
 529     QByteArray mdlData = mimeData->data("application/x-companion-modeldata");
 530     ret = mdlData.size() / (sizeof(ModelData) + 1);
 531   }
 532   return ret;
 533 }
 534
 535
 536 TreeItem * TreeModel::getItem(const QModelIndex & index) const
 537 {
 538   if (index.isValid()) {
 539     TreeItem * item = static_cast<TreeItem *>(index.internalPointer());
 540     if (item) {
 541       return item;
 542     }
 543   }
 544   return rootItem;
 545 }
 546
 547 // recursive
 548 QModelIndex TreeModel::getIndexForModel(const int modelIndex, QModelIndex parent)
 549 {
 550   for (int i=0; i < rowCount(parent); ++i) {
 551     QModelIndex idx = index(i, 0, parent);
 552     if (hasChildren(idx) && (idx = getIndexForModel(modelIndex, idx)).isValid())
 553       return idx;
 554     if (getItem(idx)->getModelIndex() == modelIndex)
 555       return idx;
 556   }
 557   return QModelIndex();
 558 }
 559
 560 QModelIndex TreeModel::getIndexForCategory(const int categoryIndex)
 561 {
 562   for (int i=0; i < rowCount(); ++i) {
 563     if (getItem(index(i, 0))->getCategoryIndex() == categoryIndex)
 564       return index(i, 0);
 565   }
 566   return QModelIndex();
 567 }
 568
 569 int TreeModel::getAvailableEEpromSize()
 570 {
 571   return availableEEpromSize;
 572 }
 573
 574 int TreeModel::getModelIndex(const QModelIndex & index) const
 575 {
 576   return getItem(index)->getModelIndex();
 577 }
 578
 579 int TreeModel::getCategoryIndex(const QModelIndex & index) const
 580 {
 581   return getItem(index)->getCategoryIndex();
 582 }
 583
 584 int TreeModel::rowNumber(const QModelIndex & index) const
 585 {
 586   return getItem(index)->childNumber();
 587 }
 588
 589 bool TreeModel::isCategoryType(const QModelIndex & index) const
 590 {
 591   return index.isValid() && getItem(index)->isCategory();
 592 }
 593
 594 bool TreeModel::isModelType(const QModelIndex & index) const
 595 {
 596   return index.isValid() && getItem(index)->isModel();
 597 }
 598
 599 void TreeModel::markItemForCut(const QModelIndex & index, bool on)
 600 {
 601   if (index.isValid() && index.column() == 0)
 602     getItem(index)->setFlag(TreeItem::MarkedForCut, on);
 603 }
 604
 605 void TreeModel::markItemsForCut(const QModelIndexList & indexes, bool on)
 606 {
 607   foreach (const QModelIndex &index, indexes)
 608     markItemForCut(index, on);
 609 }
 610
 611 // onRowsAboutToBeRemoved could be a way to deal with models being drag-drop moved to another window/file.
 612 // TreeModel detects these as removals and runs removeRows(), which deletes the Model indexes
 613 //   but not the actual models from the RadioData::models array.
 614 // BUT this also runs when moving rows within our own tree, and if there is an error during the move,
 615 //   or the user cancels the operation, removeRows() is still called automatically somewhere inside QAbstractItemModel().
 616 // If a solution could be found to this problem then we could enable DnD-moving models between file windows.
 617 /*
 618 void TreeModel::onRowsAboutToBeRemoved(const QModelIndex & parent, int first, int last)
 619 {
 620   qDebug() << parent << first << last;
 621   QVector<int> modelIndices;
 622   for (int i=first; i <= last; ++i) {
 623     modelIndices << getItem(index(i, 0, parent))->getModelIndex();
 624   }
 625   if (modelIndices.size())
 626     emit modelsRemoved(modelIndices);
 627 }
 628 */
 629
 630 void TreeModel::onRowsRemoved(const QModelIndex & parent, int first, int last)
 631 {
 632   // This is a workaround to deal with models being DnD moved to another window/file or if user cancels a DnD move within our own.
 633   //  TreeModel detects these as removals and runs removeRows(), which deletes the Model indexes but not our actual models. See notes above.
 634   //qDebug() << parent << first << last;
 635   emit refreshRequested();  // request refresh from View because it may have it's own ideas
 636 }
 637
 638 void TreeModel::refresh()
 639 {
 640   EEPROMInterface * eepromInterface = getCurrentEEpromInterface();
 641   Board::Type board = eepromInterface->getBoard();
 642   TreeItem * defaultCategoryItem = NULL;
 643   bool hasCategories = getCurrentFirmware()->getCapability(Capability::HasModelCategories);
 644   bool hasEepromSizeData = (rootItem->columnCount() > 2);
 645
 646   if (hasEepromSizeData) {
 647     availableEEpromSize = Boards::getEEpromSize(board) - 64; // let's consider fat
 648     availableEEpromSize -= 16 * ((eepromInterface->getSize(radioData->generalSettings) + 14) / 15);
 649   }
 650
 651   this->blockSignals(true);  // make sure onRowsRemoved is not triggered
 652   removeRows(0, rowCount());
 653   this->blockSignals(false);
 654
 655   if (hasCategories) {
 656     for (unsigned i = 0; i < radioData->categories.size(); i++) {
 657       TreeItem * current = rootItem->appendChild(i, -1);
 658       current->setData(0, QString(radioData->categories[i].name));
 659     }
 660   }
 661
 662   for (unsigned i=0; i<radioData->models.size(); i++) {
 663     ModelData & model = radioData->models[i];
 664     int currentColumn = 0;
 665     TreeItem * current = NULL;
 666
 667     model.modelIndex = i;
 668
 669     if (hasCategories) {
 670       if (!model.isEmpty()) {
 671         TreeItem * categoryItem;
 672         // TODO category should be set to -1 if not Horus
 673         if (model.category >= 0 && model.category < rootItem->childCount()) {
 674           categoryItem = rootItem->child(model.category);
 675         }
 676         else {
 677           model.category = 0;
 678           if (!defaultCategoryItem) {
 679             defaultCategoryItem = rootItem->appendChild(0, -1);
 680             /*: Translators do NOT use accent for this, this is the default category name on Horus. */
 681             defaultCategoryItem->setData(0, QObject::tr("Models"));
 682           }
 683           categoryItem = defaultCategoryItem;
 684         }
 685         current = categoryItem->appendChild(model.category, i);
 686       }
 687     }
 688     else {
 689       current = rootItem->appendChild(0, i);
 690       current->setData(currentColumn++, QString().sprintf("%02d", i + 1));
 691     }
 692
 693     if (!model.isEmpty() && current) {
 694       QString modelName;
 695       if (strlen(model.name) > 0) {
 696         modelName = model.name;
 697       }
 698       else {
 699         /*: Translators: do NOT use accents here, this is a default model name. */
 700         modelName = tr("Model %1").arg(uint(i+1), 2, 10, QChar('0'));
 701       }
 702       current->setData(currentColumn++, modelName);
 703       if (hasEepromSizeData) {
 704         int size = eepromInterface->getSize(model);
 705         current->setData(currentColumn++, QString().sprintf("%5d", size));
 706         size = 16 * ((size + 14) / 15);
 707         availableEEpromSize -= size;
 708         if (i == radioData->generalSettings.currModelIndex) {
 709           // Because we need this space for a TEMP model each time we have to write it again
 710           availableEEpromSize -= size;
 711         }
 712       }
 713     }
 714   }
 715
 716   if (hasEepromSizeData) {
 717     availableEEpromSize = (availableEEpromSize / 16) * 15;
 718   }
 719 }