radio/src/gui/212x64/model_logical_switches.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 "opentx.h"
  22
  23 enum LogicalSwitchFields {
  24   LS_FIELD_FUNCTION,
  25   LS_FIELD_V1,
  26   LS_FIELD_V2,
  27   LS_FIELD_V3,
  28   LS_FIELD_ANDSW,
  29   LS_FIELD_DURATION,
  30   LS_FIELD_DELAY,
  31   LS_FIELD_COUNT,
  32   LS_FIELD_LAST = LS_FIELD_COUNT-1
  33 };
  34
  35 #define CSW_1ST_COLUMN  (4*FW-3)
  36 #define CSW_2ND_COLUMN  (8*FW+2+FW/2)
  37 #define CSW_3RD_COLUMN  (14*FW+1+FW/2)
  38 #define CSW_4TH_COLUMN  (22*FW)
  39 #define CSW_5TH_COLUMN  (26*FW+3)
  40 #define CSW_6TH_COLUMN  (31*FW+1)
  41
  42 void putsEdgeDelayParam(coord_t x, coord_t y, LogicalSwitchData * cs, uint8_t lattr, uint8_t rattr)
  43 {
  44   lcdDrawChar(x-4, y, '[');
  45   lcdDrawNumber(x, y, lswTimerValue(cs->v2), LEFT|PREC1|lattr);
  46   lcdDrawChar(lcdLastRightPos, y, ':');
  47   if (cs->v3 < 0)
  48     lcdDrawText(lcdLastRightPos+3, y, "<<", rattr);
  49   else if (cs->v3 == 0)
  50     lcdDrawText(lcdLastRightPos+3, y, "--", rattr);
  51   else
  52     lcdDrawNumber(lcdLastRightPos+3, y, lswTimerValue(cs->v2+cs->v3), LEFT|PREC1|rattr);
  53   lcdDrawChar(lcdLastRightPos, y, ']');
  54 }
  55
  56 void onLogicalSwitchesMenu(const char *result)
  57 {
  58   int8_t sub = menuVerticalPosition;
  59   LogicalSwitchData * cs = lswAddress(sub);
  60
  61   if (result == STR_COPY) {
  62     clipboard.type = CLIPBOARD_TYPE_CUSTOM_SWITCH;
  63     clipboard.data.csw = *cs;
  64   }
  65   else if (result == STR_PASTE) {
  66     *cs = clipboard.data.csw;
  67     storageDirty(EE_MODEL);
  68   }
  69   else if (result == STR_CLEAR) {
  70     memset(cs, 0, sizeof(LogicalSwitchData));
  71     storageDirty(EE_MODEL);
  72   }
  73 }
  74
  75 void menuModelLogicalSwitches(event_t event)
  76 {
  77   INCDEC_DECLARE_VARS(EE_MODEL);
  78
  79   MENU(STR_MENULOGICALSWITCHES, menuTabModel, MENU_MODEL_LOGICAL_SWITCHES, MAX_LOGICAL_SWITCHES, { NAVIGATION_LINE_BY_LINE|LS_FIELD_LAST/*repeated...*/ });
  80
  81   int k = 0;
  82   int sub = menuVerticalPosition;
  83   horzpos_t horz = menuHorizontalPosition;
  84
  85   if (horz>=0) {
  86     drawColumnHeader(STR_LSW_HEADERS, horz);
  87   }
  88
  89   if (horz<0 && event==EVT_KEY_LONG(KEY_ENTER) && !READ_ONLY()) {
  90     killEvents(event);
  91     LogicalSwitchData * cs = lswAddress(sub);
  92     if (cs->func)
  93       POPUP_MENU_ADD_ITEM(STR_COPY);
  94     if (clipboard.type == CLIPBOARD_TYPE_CUSTOM_SWITCH)
  95       POPUP_MENU_ADD_ITEM(STR_PASTE);
  96     if (cs->func || cs->v1 || cs->v2 || cs->delay || cs->duration || cs->andsw)
  97       POPUP_MENU_ADD_ITEM(STR_CLEAR);
  98     POPUP_MENU_START(onLogicalSwitchesMenu);
  99   }
 100
 101   for (uint8_t i=0; i<NUM_BODY_LINES; ++i) {
 102     coord_t y = MENU_HEADER_HEIGHT + 1 + i*FH;
 103     k = i+menuVerticalOffset;
 104     LcdFlags attr = (sub==k ? ((s_editMode>0) ? BLINK|INVERS : INVERS)  : 0);
 105     LcdFlags attr1 = (horz==1 ? attr : 0);
 106     LcdFlags attr2 = (horz==2 ? attr : 0);
 107     LogicalSwitchData * cs = lswAddress(k);
 108
 109     // CSW name
 110     unsigned int sw = SWSRC_SW1+k;
 111     drawSwitch(0, y, sw, (getSwitch(sw) ? BOLD : 0) | ((sub==k && CURSOR_ON_LINE()) ? INVERS : 0));
 112
 113     // CSW func
 114     lcdDrawTextAtIndex(CSW_1ST_COLUMN, y, STR_VCSWFUNC, cs->func, horz==0 ? attr : 0);
 115
 116     // CSW params
 117     unsigned int cstate = lswFamily(cs->func);
 118     int v1_val=cs->v1, v1_min=0, v1_max=MIXSRC_LAST_TELEM;
 119     int v2_min=0, v2_max=MIXSRC_LAST_TELEM;
 120     int v3_min=-1, v3_max=100;
 121
 122     if (cstate == LS_FAMILY_BOOL || cstate == LS_FAMILY_STICKY) {
 123       drawSwitch(CSW_2ND_COLUMN, y, cs->v1, attr1);
 124       drawSwitch(CSW_3RD_COLUMN, y, cs->v2, attr2);
 125       v1_min = SWSRC_FIRST_IN_LOGICAL_SWITCHES; v1_max = SWSRC_LAST_IN_LOGICAL_SWITCHES;
 126       v2_min = SWSRC_FIRST_IN_LOGICAL_SWITCHES; v2_max = SWSRC_LAST_IN_LOGICAL_SWITCHES;
 127       INCDEC_SET_FLAG(EE_MODEL | INCDEC_SWITCH);
 128       INCDEC_ENABLE_CHECK(isSwitchAvailableInLogicalSwitches);
 129     }
 130     else if (cstate == LS_FAMILY_EDGE) {
 131       drawSwitch(CSW_2ND_COLUMN, y, cs->v1, attr1);
 132       putsEdgeDelayParam(CSW_3RD_COLUMN, y, cs, attr2, horz==LS_FIELD_V3 ? attr : 0);
 133       v1_min = SWSRC_FIRST_IN_LOGICAL_SWITCHES; v1_max = SWSRC_LAST_IN_LOGICAL_SWITCHES;
 134       v2_min=-129; v2_max = 122;
 135       v3_max = 222 - cs->v2;
 136       if (horz == 1) {
 137         INCDEC_SET_FLAG(EE_MODEL | INCDEC_SWITCH);
 138         INCDEC_ENABLE_CHECK(isSwitchAvailableInLogicalSwitches);
 139       }
 140       else {
 141         INCDEC_SET_FLAG(EE_MODEL);
 142         INCDEC_ENABLE_CHECK(NULL);
 143       }
 144     }
 145     else if (cstate == LS_FAMILY_COMP) {
 146       v1_val = cs->v1;
 147       drawSource(CSW_2ND_COLUMN, y, v1_val, attr1);
 148       drawSource(CSW_3RD_COLUMN, y, cs->v2, attr2);
 149       INCDEC_SET_FLAG(EE_MODEL | INCDEC_SOURCE);
 150       INCDEC_ENABLE_CHECK(isSourceAvailable);
 151     }
 152     else if (cstate == LS_FAMILY_TIMER) {
 153       lcdDrawNumber(CSW_2ND_COLUMN, y, lswTimerValue(cs->v1), LEFT|PREC1|attr1);
 154       lcdDrawNumber(CSW_3RD_COLUMN, y, lswTimerValue(cs->v2), LEFT|PREC1|attr2);
 155       v1_min = v2_min = -128;
 156       v1_max = v2_max = 122;
 157       INCDEC_SET_FLAG(EE_MODEL);
 158       INCDEC_ENABLE_CHECK(NULL);
 159     }
 160     else {
 161       v1_val = cs->v1;
 162       drawSource(CSW_2ND_COLUMN, y, v1_val, attr1);
 163       if (horz == 1) {
 164         INCDEC_SET_FLAG(EE_MODEL | INCDEC_SOURCE);
 165         INCDEC_ENABLE_CHECK(isSourceAvailableInCustomSwitches);
 166       }
 167       else {
 168         INCDEC_SET_FLAG(EE_MODEL);
 169         INCDEC_ENABLE_CHECK(NULL);
 170       }
 171       v2_max = getMaximumValue(v1_val);
 172       v2_min = - v2_max;
 173       if (v1_val <= MIXSRC_LAST_CH) {
 174         drawSourceCustomValue(CSW_3RD_COLUMN, y, v1_val, calc100toRESX(cs->v2), LEFT|attr2);
 175       }
 176       else {
 177         drawSourceCustomValue(CSW_3RD_COLUMN, y, v1_val, cs->v2, LEFT|attr2);
 178       }
 179     }
 180
 181     // CSW AND switch
 182     drawSwitch(CSW_4TH_COLUMN, y, cs->andsw, horz==LS_FIELD_ANDSW ? attr : 0);
 183
 184     // CSW duration
 185     if (cs->duration > 0)
 186       lcdDrawNumber(CSW_5TH_COLUMN, y, cs->duration, (horz==LS_FIELD_DURATION ? attr : 0)|PREC1|LEFT);
 187     else
 188       lcdDrawMMM(CSW_5TH_COLUMN, y, horz==LS_FIELD_DURATION ? attr : 0);
 189
 190     // CSW delay
 191     if (cstate == LS_FAMILY_EDGE) {
 192       lcdDrawText(CSW_6TH_COLUMN, y, STR_NA);
 193       if (attr && horz == LS_FIELD_DELAY) {
 194         REPEAT_LAST_CURSOR_MOVE();
 195       }
 196     }
 197     else if (cs->delay > 0) {
 198       lcdDrawNumber(CSW_6TH_COLUMN, y, cs->delay, (horz==LS_FIELD_DELAY ? attr : 0)|PREC1|LEFT);
 199     }
 200     else {
 201       lcdDrawMMM(CSW_6TH_COLUMN, y, horz==LS_FIELD_DELAY ? attr : 0);
 202     }
 203
 204     if (attr && horz == LS_FIELD_V3 && cstate != LS_FAMILY_EDGE) {
 205       REPEAT_LAST_CURSOR_MOVE();
 206     }
 207
 208     if (s_editMode>0 && attr) {
 209       switch (horz) {
 210         case LS_FIELD_FUNCTION:
 211         {
 212           cs->func = checkIncDec(event, cs->func, 0, LS_FUNC_MAX, EE_MODEL, isLogicalSwitchFunctionAvailable);
 213           uint8_t new_cstate = lswFamily(cs->func);
 214           if (cstate != new_cstate) {
 215             unsigned int save_func = cs->func;
 216             memset(cs, 0, sizeof(LogicalSwitchData));
 217             cs->func = save_func;
 218             if (new_cstate == LS_FAMILY_TIMER) {
 219               cs->v1 = cs->v2 = -119;
 220             }
 221             else if (new_cstate == LS_FAMILY_EDGE) {
 222               cs->v2 = -129;
 223             }
 224           }
 225           break;
 226         }
 227         case LS_FIELD_V1:
 228           cs->v1 = CHECK_INCDEC_PARAM(event, v1_val, v1_min, v1_max);
 229           break;
 230         case LS_FIELD_V2:
 231           if (v1_val >= MIXSRC_FIRST_TIMER) {
 232             INCDEC_SET_FLAG(EE_MODEL | INCDEC_REP10 | NO_INCDEC_MARKS);
 233           }
 234           cs->v2 = CHECK_INCDEC_PARAM(event, cs->v2, v2_min, v2_max);
 235           if (cstate==LS_FAMILY_OFS && cs->v1!=0 && event==EVT_KEY_LONG(KEY_ENTER)) {
 236             killEvents(event);
 237             getvalue_t x = getValue(v1_val);
 238             if (v1_val <= MIXSRC_LAST_CH) {
 239               cs->v2 = calcRESXto100(x);
 240             }
 241             storageDirty(EE_MODEL);
 242           }
 243           break;
 244         case LS_FIELD_V3:
 245           cs->v3 = CHECK_INCDEC_PARAM(event, cs->v3, v3_min, v3_max);
 246           break;
 247         case LS_FIELD_ANDSW:
 248           INCDEC_SET_FLAG(EE_MODEL | INCDEC_SWITCH);
 249           INCDEC_ENABLE_CHECK(isSwitchAvailableInLogicalSwitches);
 250           cs->andsw = CHECK_INCDEC_PARAM(event, cs->andsw, -MAX_LS_ANDSW, MAX_LS_ANDSW);
 251           break;
 252         case LS_FIELD_DURATION:
 253           CHECK_INCDEC_MODELVAR_ZERO(event, cs->duration, MAX_LS_DURATION);
 254           break;
 255         case LS_FIELD_DELAY:
 256           CHECK_INCDEC_MODELVAR_ZERO(event, cs->delay, MAX_LS_DELAY);
 257           break;
 258       }
 259     }
 260   }
 261 }