520 lines
16 KiB
C++
520 lines
16 KiB
C++
/*
|
|
* Copyright (C) OpenTX
|
|
*
|
|
* Based on code named
|
|
* th9x - http://code.google.com/p/th9x
|
|
* er9x - http://code.google.com/p/er9x
|
|
* gruvin9x - http://code.google.com/p/gruvin9x
|
|
*
|
|
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "opentx.h"
|
|
#include "storage/modelslist.h"
|
|
|
|
#define CATEGORIES_WIDTH 120
|
|
#define MODELS_LEFT 123
|
|
#define MODELS_COLUMN_WIDTH 174
|
|
|
|
enum ModelSelectMode {
|
|
MODE_SELECT_MODEL,
|
|
MODE_RENAME_CATEGORY,
|
|
MODE_MOVE_MODEL,
|
|
};
|
|
|
|
enum ModelDeleteMode {
|
|
MODE_DELETE_MODEL,
|
|
MODE_DELETE_CATEGORY,
|
|
};
|
|
|
|
uint8_t selectMode, deleteMode;
|
|
|
|
ModelsCategory * currentCategory;
|
|
int currentCategoryIndex;
|
|
ModelCell * currentModel;
|
|
|
|
void drawCategory(coord_t y, const char * name, bool selected)
|
|
{
|
|
if (selected) {
|
|
lcdDrawSolidFilledRect(1, y-INVERT_VERT_MARGIN, CATEGORIES_WIDTH-10, INVERT_LINE_HEIGHT+2, TEXT_INVERTED_BGCOLOR);
|
|
lcdDrawText(6, y, name, TEXT_COLOR | INVERS);
|
|
}
|
|
else {
|
|
lcdDrawText(6, y, name, TEXT_COLOR);
|
|
}
|
|
}
|
|
|
|
void drawModel(coord_t x, coord_t y, ModelCell * model, bool current, bool selected)
|
|
{
|
|
lcd->drawBitmap(x+1, y+1, model->getBuffer());
|
|
if (current) {
|
|
lcd->drawBitmapPattern(x+66, y+43, LBM_ACTIVE_MODEL, TITLE_BGCOLOR);
|
|
}
|
|
if (selected) {
|
|
lcdDrawSolidRect(x, y, MODELCELL_WIDTH+2, MODELCELL_HEIGHT+2, 1, TITLE_BGCOLOR);
|
|
drawShadow(x, y, MODELCELL_WIDTH+2, MODELCELL_HEIGHT+2);
|
|
if (selectMode == MODE_MOVE_MODEL) {
|
|
lcd->drawMask(x+MODELCELL_WIDTH+2-modelselModelMoveBackground->getWidth(), y, modelselModelMoveBackground, TITLE_BGCOLOR);
|
|
lcd->drawMask(x+MODELCELL_WIDTH+2-modelselModelMoveBackground->getWidth()+12, y+5, modelselModelMoveIcon, TEXT_BGCOLOR);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint16_t categoriesVerticalOffset = 0;
|
|
uint16_t categoriesVerticalPosition = 0;
|
|
#define MODEL_INDEX() (menuVerticalPosition*2+menuHorizontalPosition)
|
|
|
|
void setCurrentModel(unsigned int index)
|
|
{
|
|
std::list<ModelCell *>::iterator it = currentCategory->begin();
|
|
std::advance(it, index);
|
|
currentModel = *it;
|
|
menuVerticalPosition = index / 2;
|
|
menuHorizontalPosition = index & 1;
|
|
menuVerticalOffset = limit<int>(menuVerticalPosition-2, menuVerticalOffset, min<int>(menuVerticalPosition, max<int>(0, (currentCategory->size()-7)/2)));
|
|
}
|
|
|
|
void setCurrentCategory(unsigned int index)
|
|
{
|
|
currentCategoryIndex = index;
|
|
const std::list<ModelsCategory *>& cats = modelslist.getCategories();
|
|
std::list<ModelsCategory *>::const_iterator it = cats.begin();
|
|
std::advance(it, index);
|
|
currentCategory = *it;
|
|
categoriesVerticalPosition = index;
|
|
categoriesVerticalOffset = limit<int>(categoriesVerticalPosition-4, categoriesVerticalOffset, min<int>(categoriesVerticalPosition, max<int>(0, cats.size()-5)));
|
|
if (currentCategory->size() > 0)
|
|
setCurrentModel(0);
|
|
else
|
|
currentModel = NULL;
|
|
}
|
|
|
|
#if defined(LUA)
|
|
|
|
#define MAX_WIZARD_NAME_LEN (sizeof(WIZARD_PATH)+20)
|
|
#define WIZARD_SPACING 40
|
|
#define WIZARD_LEFT_SPACING 30
|
|
#define WIZARD_ICON_X 80
|
|
#define WIZARD_ICON_Y 110
|
|
#define WIZARD_TEXT_Y 195
|
|
|
|
uint8_t getWizardCount()
|
|
{
|
|
uint8_t wizCnt=0;
|
|
DIR dir;
|
|
static FILINFO fno;
|
|
|
|
FRESULT res = f_opendir(&dir, WIZARD_PATH);
|
|
if (res == FR_OK) {
|
|
for (;;) {
|
|
res = f_readdir(&dir, &fno);
|
|
if (res != FR_OK || fno.fname[0] == 0) {
|
|
break;
|
|
}
|
|
if (fno.fattrib & AM_DIR) {
|
|
wizCnt++;
|
|
}
|
|
}
|
|
}
|
|
f_closedir(&dir);
|
|
return wizCnt;
|
|
}
|
|
|
|
bool menuModelWizard(event_t event)
|
|
{
|
|
static uint8_t wizardSelected = 0;
|
|
static uint8_t wizardCnt = getWizardCount();
|
|
bool executeMe = false;
|
|
uint8_t first = 0;
|
|
DIR dir;
|
|
static FILINFO fno;
|
|
char wizpath[MAX_WIZARD_NAME_LEN];
|
|
|
|
if (wizardCnt == 0) {
|
|
chainMenu(menuModelSelect);
|
|
return false;
|
|
}
|
|
|
|
switch(event) {
|
|
case 0:
|
|
// no need to refresh the screen
|
|
return false;
|
|
|
|
case EVT_KEY_FIRST(KEY_EXIT):
|
|
chainMenu(menuModelSelect);
|
|
return false;
|
|
|
|
case EVT_KEY_BREAK(KEY_ENTER):
|
|
executeMe = true;
|
|
break;
|
|
|
|
case EVT_ROTARY_RIGHT:
|
|
if (wizardSelected < wizardCnt-1) {
|
|
wizardSelected++;
|
|
}
|
|
if (wizardSelected > 3) {
|
|
first = wizardSelected - 3;
|
|
}
|
|
break;
|
|
|
|
case EVT_ROTARY_LEFT:
|
|
if (wizardSelected != 0) {
|
|
wizardSelected--;
|
|
}
|
|
if(wizardSelected < first)
|
|
{
|
|
first = wizardSelected;
|
|
}
|
|
break;
|
|
}
|
|
strcpy(wizpath, WIZARD_PATH);
|
|
strcpy(&wizpath[sizeof(WIZARD_PATH)-1], "/");
|
|
lcdDrawSolidFilledRect(0, 0, LCD_W, LCD_H, TEXT_BGCOLOR);
|
|
lcd->drawBitmap(0, 0, modelselWizardBackground);
|
|
FRESULT res = f_opendir(&dir, WIZARD_PATH);
|
|
if (res == FR_OK) {
|
|
for (uint8_t wizidx=0;;wizidx++) {
|
|
res = f_readdir(&dir, &fno);
|
|
if (res != FR_OK || fno.fname[0] == 0) {
|
|
break;
|
|
}
|
|
if (fno.fattrib & AM_DIR) {
|
|
if((wizidx >= first) && (wizidx < (first+4))) {
|
|
uint16_t x = WIZARD_LEFT_SPACING + (wizidx - first) * (WIZARD_SPACING + WIZARD_ICON_X);
|
|
strcpy(&wizpath[sizeof(WIZARD_PATH)], fno.fname);
|
|
strcpy(&wizpath[sizeof(WIZARD_PATH) + strlen(fno.fname)], "/icon.png");
|
|
lcdDrawText(x + 10, WIZARD_TEXT_Y, fno.fname);
|
|
BitmapBuffer * background = BitmapBuffer::load(wizpath);
|
|
lcd->drawBitmap(x, WIZARD_ICON_Y, background);
|
|
if(wizidx == wizardSelected ) {
|
|
if (wizardSelected < 5) {
|
|
lcdDrawRect(x, WIZARD_ICON_Y, 85, 130, 2, SOLID, MAINVIEW_GRAPHICS_COLOR_INDEX);
|
|
lcdDrawRect(x+5, WIZARD_TEXT_Y, 75, 4, 2, SOLID, MAINVIEW_GRAPHICS_COLOR_INDEX);
|
|
}
|
|
if (executeMe) {
|
|
strcpy(&wizpath[sizeof(WIZARD_PATH)+strlen(fno.fname)], "/wizard.lua");
|
|
if (isFileAvailable(wizpath)) {
|
|
wizpath[sizeof(WIZARD_PATH) + strlen(fno.fname)] = 0;
|
|
f_chdir(wizpath);
|
|
luaExec(WIZARD_NAME);
|
|
}
|
|
}
|
|
}
|
|
delete background;
|
|
}
|
|
}
|
|
}
|
|
f_closedir(&dir);
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
void onDeleteModelConfirm(const char * result)
|
|
{
|
|
if (result == STR_OK) {
|
|
if (deleteMode == MODE_DELETE_CATEGORY) {
|
|
modelslist.removeCategory(currentCategory);
|
|
modelslist.save();
|
|
setCurrentCategory(currentCategoryIndex > 0 ? currentCategoryIndex-1 : currentCategoryIndex);
|
|
}
|
|
else if (deleteMode == MODE_DELETE_MODEL){
|
|
int modelIndex = MODEL_INDEX();
|
|
modelslist.removeModel(currentCategory, currentModel);
|
|
s_copyMode = 0;
|
|
putEvent(EVT_REFRESH);
|
|
if (modelIndex > 0) {
|
|
modelIndex--;
|
|
}
|
|
setCurrentModel(modelIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
void onModelSelectMenu(const char * result)
|
|
{
|
|
if (result == STR_SELECT_MODEL) {
|
|
// we store the latest changes if any
|
|
storageFlushCurrentModel();
|
|
storageCheck(true);
|
|
memcpy(g_eeGeneral.currModelFilename, currentModel->modelFilename, LEN_MODEL_FILENAME);
|
|
modelslist.setCurrentModel(currentModel);
|
|
loadModel(g_eeGeneral.currModelFilename, true);
|
|
storageDirty(EE_GENERAL);
|
|
storageCheck(true);
|
|
chainMenu(menuMainView);
|
|
}
|
|
else if (result == STR_DELETE_MODEL) {
|
|
POPUP_CONFIRMATION(STR_DELETEMODEL, onDeleteModelConfirm);
|
|
SET_WARNING_INFO(currentModel->modelName, LEN_MODEL_NAME, 0);
|
|
deleteMode = MODE_DELETE_MODEL;
|
|
}
|
|
else if (result == STR_CREATE_MODEL) {
|
|
storageCheck(true);
|
|
modelslist.addModel(currentCategory, createModel());
|
|
selectMode = MODE_SELECT_MODEL;
|
|
setCurrentModel(currentCategory->size() - 1);
|
|
modelslist.setCurrentModel(currentModel);
|
|
modelslist.onNewModelCreated(currentModel, &g_model);
|
|
#if defined(LUA)
|
|
chainMenu(menuModelWizard);
|
|
#endif
|
|
}
|
|
else if (result == STR_DUPLICATE_MODEL) {
|
|
char duplicatedFilename[LEN_MODEL_FILENAME+1];
|
|
memcpy(duplicatedFilename, currentModel->modelFilename, sizeof(duplicatedFilename));
|
|
if (findNextFileIndex(duplicatedFilename, LEN_MODEL_FILENAME, MODELS_PATH)) {
|
|
sdCopyFile(currentModel->modelFilename, MODELS_PATH, duplicatedFilename, MODELS_PATH);
|
|
ModelCell* dup_model = modelslist.addModel(currentCategory, duplicatedFilename);
|
|
dup_model->fetchRfData();
|
|
setCurrentModel(currentCategory->size() - 1);
|
|
}
|
|
else {
|
|
POPUP_WARNING(STR_INVALID_FILE);
|
|
}
|
|
}
|
|
else if (result == STR_MOVE_MODEL) {
|
|
selectMode = MODE_MOVE_MODEL;
|
|
}
|
|
else if (result == STR_CREATE_CATEGORY) {
|
|
currentCategory = modelslist.createCategory();
|
|
setCurrentCategory(modelslist.getCategories().size() - 1);
|
|
}
|
|
else if (result == STR_RENAME_CATEGORY) {
|
|
selectMode = MODE_RENAME_CATEGORY;
|
|
s_editMode = EDIT_MODIFY_STRING;
|
|
editNameCursorPos = 0;
|
|
}
|
|
else if (result == STR_DELETE_CATEGORY) {
|
|
if (currentCategory->size() > 0){
|
|
POPUP_WARNING(STR_DELETE_ERROR);
|
|
SET_WARNING_INFO(STR_CAT_NOT_EMPTY, sizeof(TR_CAT_NOT_EMPTY), 0);
|
|
}
|
|
else {
|
|
POPUP_CONFIRMATION(STR_DELETEMODEL, onDeleteModelConfirm);
|
|
SET_WARNING_INFO(currentCategory->name, LEN_MODEL_FILENAME, 0);
|
|
deleteMode = MODE_DELETE_CATEGORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
void initModelsList()
|
|
{
|
|
modelslist.load();
|
|
|
|
categoriesVerticalOffset = 0;
|
|
bool found = false;
|
|
int index = 0;
|
|
const std::list<ModelsCategory *>& cats = modelslist.getCategories();
|
|
for (std::list<ModelsCategory *>::const_iterator it = cats.begin(); it != cats.end(); ++it, ++index) {
|
|
if (*it == modelslist.getCurrentCategory()) {
|
|
setCurrentCategory(index);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
setCurrentCategory(0);
|
|
}
|
|
|
|
menuVerticalOffset = 0;
|
|
found = false;
|
|
index = 0;
|
|
for (ModelsCategory::iterator it = currentCategory->begin(); it != currentCategory->end(); ++it, ++index) {
|
|
if (*it == modelslist.getCurrentModel()) {
|
|
setCurrentModel(index);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
setCurrentModel(0);
|
|
}
|
|
}
|
|
|
|
bool menuModelSelect(event_t event)
|
|
{
|
|
const std::list<ModelsCategory*>& cats = modelslist.getCategories();
|
|
switch(event) {
|
|
case 0:
|
|
// no need to refresh the screen
|
|
return false;
|
|
|
|
case EVT_ENTRY:
|
|
selectMode = MODE_SELECT_MODEL;
|
|
initModelsList();
|
|
break;
|
|
|
|
case EVT_KEY_BREAK(KEY_ENTER):
|
|
if (selectMode == MODE_MOVE_MODEL)
|
|
selectMode = MODE_SELECT_MODEL;
|
|
break;
|
|
|
|
case EVT_KEY_FIRST(KEY_EXIT):
|
|
switch (selectMode) {
|
|
case MODE_MOVE_MODEL:
|
|
selectMode = MODE_SELECT_MODEL;
|
|
break;
|
|
case MODE_SELECT_MODEL:
|
|
chainMenu(menuMainView);
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
case EVT_KEY_FIRST(KEY_PGUP):
|
|
#if defined(PCBX10)
|
|
case EVT_KEY_LONG(KEY_PGDN):
|
|
#endif
|
|
if (selectMode == MODE_SELECT_MODEL) {
|
|
if (categoriesVerticalPosition == 0)
|
|
categoriesVerticalPosition = cats.size() - 1;
|
|
else
|
|
categoriesVerticalPosition -= 1;
|
|
setCurrentCategory(categoriesVerticalPosition);
|
|
}
|
|
else if (selectMode == MODE_MOVE_MODEL && categoriesVerticalPosition > 0) {
|
|
ModelsCategory * previous_category = currentCategory;
|
|
ModelCell * model = currentModel;
|
|
categoriesVerticalPosition -= 1;
|
|
setCurrentCategory(categoriesVerticalPosition);
|
|
modelslist.moveModel(model, previous_category, currentCategory);
|
|
setCurrentModel(currentCategory->size()-1);
|
|
}
|
|
killEvents(event);
|
|
break;
|
|
|
|
#if defined(PCBX12S)
|
|
case EVT_KEY_FIRST(KEY_PGDN):
|
|
#elif defined(PCBX10)
|
|
case EVT_KEY_BREAK(KEY_PGDN):
|
|
#endif
|
|
if (selectMode == MODE_SELECT_MODEL) {
|
|
categoriesVerticalPosition += 1;
|
|
if (categoriesVerticalPosition >= cats.size())
|
|
categoriesVerticalPosition = 0;
|
|
setCurrentCategory(categoriesVerticalPosition);
|
|
}
|
|
else if (selectMode == MODE_MOVE_MODEL && categoriesVerticalPosition < cats.size()-1) {
|
|
ModelsCategory * previous_category = currentCategory;
|
|
ModelCell * model = currentModel;
|
|
categoriesVerticalPosition += 1;
|
|
setCurrentCategory(categoriesVerticalPosition);
|
|
modelslist.moveModel(model, previous_category, currentCategory);
|
|
setCurrentModel(currentCategory->size()-1);
|
|
}
|
|
break;
|
|
|
|
case EVT_KEY_LONG(KEY_ENTER):
|
|
if (selectMode == MODE_SELECT_MODEL) {
|
|
killEvents(event);
|
|
if (currentModel && currentModel != modelslist.getCurrentModel()) {
|
|
POPUP_MENU_ADD_ITEM(STR_SELECT_MODEL);
|
|
}
|
|
POPUP_MENU_ADD_ITEM(STR_CREATE_MODEL);
|
|
if (currentModel) {
|
|
POPUP_MENU_ADD_ITEM(STR_DUPLICATE_MODEL);
|
|
POPUP_MENU_ADD_ITEM(STR_MOVE_MODEL);
|
|
}
|
|
// POPUP_MENU_ADD_SD_ITEM(STR_BACKUP_MODEL);
|
|
if (currentModel && currentModel != modelslist.getCurrentModel()) {
|
|
POPUP_MENU_ADD_ITEM(STR_DELETE_MODEL);
|
|
}
|
|
// POPUP_MENU_ADD_ITEM(STR_RESTORE_MODEL);
|
|
POPUP_MENU_ADD_ITEM(STR_CREATE_CATEGORY);
|
|
POPUP_MENU_ADD_ITEM(STR_RENAME_CATEGORY);
|
|
if (cats.size() > 1) {
|
|
POPUP_MENU_ADD_ITEM(STR_DELETE_CATEGORY);
|
|
}
|
|
POPUP_MENU_START(onModelSelectMenu);
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
lcdDrawSolidFilledRect(0, 0, LCD_W, LCD_H, TEXT_BGCOLOR);
|
|
lcd->drawBitmap(0, 0, modelselIconBitmap);
|
|
|
|
// Categories
|
|
int index = 0;
|
|
coord_t y = 97;
|
|
drawVerticalScrollbar(CATEGORIES_WIDTH-1, y-1, 5*(FH+7)-5, categoriesVerticalOffset, cats.size(), 5);
|
|
for (std::list<ModelsCategory *>::const_iterator it = cats.begin(); it != cats.end(); ++it, ++index) {
|
|
if (index >= categoriesVerticalOffset && index < categoriesVerticalOffset+5) {
|
|
if (index != categoriesVerticalOffset) {
|
|
lcdDrawSolidHorizontalLine(1, y-4, CATEGORIES_WIDTH-10, LINE_COLOR);
|
|
}
|
|
if (selectMode == MODE_RENAME_CATEGORY && currentCategory == *it) {
|
|
lcdDrawSolidFilledRect(0, y-INVERT_VERT_MARGIN+1, CATEGORIES_WIDTH-2, INVERT_LINE_HEIGHT, TEXT_BGCOLOR);
|
|
editName(MENUS_MARGIN_LEFT, y, currentCategory->name, LEN_MODEL_FILENAME, event, 1, 0);
|
|
if (s_editMode == 0 || event == EVT_KEY_BREAK(KEY_EXIT)) {
|
|
modelslist.save();
|
|
selectMode = MODE_SELECT_MODEL;
|
|
putEvent(EVT_REFRESH);
|
|
}
|
|
}
|
|
else {
|
|
drawCategory(y, (*it)->name, currentCategory==*it);
|
|
}
|
|
y += FH+7;
|
|
}
|
|
}
|
|
|
|
// Models
|
|
index = 0;
|
|
y = 5;
|
|
for (ModelsCategory::iterator it = currentCategory->begin(); it != currentCategory->end(); ++it, ++index) {
|
|
if (index >= menuVerticalOffset*2 && index < (menuVerticalOffset+4)*2) {
|
|
bool selected = ((selectMode==MODE_SELECT_MODEL || selectMode==MODE_MOVE_MODEL) && index==menuVerticalPosition*2+menuHorizontalPosition);
|
|
bool current = !strncmp((*it)->modelFilename, g_eeGeneral.currModelFilename, LEN_MODEL_FILENAME);
|
|
if (index & 1) {
|
|
drawModel(MODELS_LEFT + MODELS_COLUMN_WIDTH, y, *it, current, selected);
|
|
y += 66;
|
|
}
|
|
else {
|
|
drawModel(MODELS_LEFT, y, *it, current, selected);
|
|
}
|
|
if (selected) {
|
|
lcd->drawBitmap(5, LCD_H-FH, modelselModelNameBitmap);
|
|
lcdDrawText(22, LCD_H-FH-1, (*it)->modelFilename, SMLSIZE|TEXT_COLOR);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Navigation
|
|
if (currentModel) {
|
|
if (selectMode == MODE_SELECT_MODEL) {
|
|
if (navigate(event, index, 4, 2) != 0) {
|
|
setCurrentModel(MODEL_INDEX());
|
|
putEvent(EVT_REFRESH);
|
|
}
|
|
}
|
|
else if (selectMode == MODE_MOVE_MODEL) {
|
|
int8_t direction = navigate(event, index, 4, 2, false);
|
|
if (direction) {
|
|
modelslist.moveModel(currentCategory, currentModel, direction);
|
|
setCurrentModel(MODEL_INDEX());
|
|
putEvent(EVT_REFRESH);
|
|
}
|
|
}
|
|
}
|
|
drawVerticalScrollbar(DEFAULT_SCROLLBAR_X + 4, 7, LCD_H - 15, menuVerticalOffset, (index + 1) / 2, 4);
|
|
|
|
// Footer
|
|
lcd->drawBitmap(5, LCD_H-FH-20, modelselSdFreeBitmap);
|
|
uint32_t size = sdGetSize() / 100;
|
|
lcdDrawNumber(22, LCD_H-FH-21, size, PREC1|SMLSIZE, 0, NULL, "GB");
|
|
lcd->drawBitmap(70, LCD_H-FH-20, modelselModelQtyBitmap);
|
|
lcdDrawNumber(92, LCD_H-FH-21, modelslist.getModelsCount(),SMLSIZE);
|
|
|
|
return true;
|
|
}
|