Browse Source

Fix SD card reselect when scrolled (#13624)

- Change encoder position to 16-bit integer.
- Fix `SD_REPRINT_LAST_SELECTED_FILE` when the screen is scrolled.
Scott Lahteine 6 years ago
parent
commit
321a5e6580
No account linked to committer's email address

+ 1
- 1
Marlin/src/lcd/menu/game/invaders.cpp View File

@@ -263,7 +263,7 @@ void InvadersGame::game_screen() {
263 263
   if (ui.first_page) {
264 264
 
265 265
     // Update Cannon Position
266
-    int32_t ep = (int32_t)ui.encoderPosition;
266
+    int16_t ep = int16_t(ui.encoderPosition);
267 267
     ep = constrain(ep, 0, (LCD_PIXEL_WIDTH - (CANNON_W)) / (CANNON_VEL));
268 268
     ui.encoderPosition = ep;
269 269
 

+ 11
- 11
Marlin/src/lcd/menu/menu.cpp View File

@@ -66,11 +66,11 @@ uint8_t screen_history_depth = 0;
66 66
 bool screen_changed;
67 67
 
68 68
 // Value Editing
69
-PGM_P editLabel;
70
-void *editValue;
71
-int32_t minEditValue, maxEditValue;
72
-screenFunc_t callbackFunc;
73
-bool liveEdit;
69
+PGM_P MenuItemBase::editLabel;
70
+void* MenuItemBase::editValue;
71
+int16_t MenuItemBase::minEditValue, MenuItemBase::maxEditValue;
72
+screenFunc_t MenuItemBase::callbackFunc;
73
+bool MenuItemBase::liveEdit;
74 74
 
75 75
 // Prevent recursion into screen handlers
76 76
 bool no_reentry = false;
@@ -131,8 +131,8 @@ void MenuItem_gcode::action(PGM_P pgcode) { enqueue_and_echo_commands_P(pgcode);
131 131
  */
132 132
 void MenuItemBase::edit(strfunc_t strfunc, loadfunc_t loadfunc) {
133 133
   ui.encoder_direction_normal();
134
-  if ((int32_t)ui.encoderPosition < 0) ui.encoderPosition = 0;
135
-  if ((int32_t)ui.encoderPosition > maxEditValue) ui.encoderPosition = maxEditValue;
134
+  if (int16_t(ui.encoderPosition) < 0) ui.encoderPosition = 0;
135
+  if (int16_t(ui.encoderPosition) > maxEditValue) ui.encoderPosition = maxEditValue;
136 136
   if (ui.should_draw())
137 137
     draw_edit_screen(editLabel, strfunc(ui.encoderPosition + minEditValue));
138 138
   if (ui.lcd_clicked || (liveEdit && ui.should_draw())) {
@@ -142,7 +142,7 @@ void MenuItemBase::edit(strfunc_t strfunc, loadfunc_t loadfunc) {
142 142
   }
143 143
 }
144 144
 
145
-void MenuItemBase::init(PGM_P const el, void * const ev, const int32_t minv, const int32_t maxv, const uint32_t ep, const screenFunc_t cs, const screenFunc_t cb, const bool le) {
145
+void MenuItemBase::init(PGM_P const el, void * const ev, const int16_t minv, const int16_t maxv, const uint16_t ep, const screenFunc_t cs, const screenFunc_t cb, const bool le) {
146 146
   ui.save_previous_screen();
147 147
   ui.refresh();
148 148
   editLabel = el;
@@ -193,7 +193,7 @@ bool printer_busy() {
193 193
 /**
194 194
  * General function to go directly to a screen
195 195
  */
196
-void MarlinUI::goto_screen(screenFunc_t screen, const uint32_t encoder/*=0*/, const uint8_t top/*=0*/, const uint8_t items/*=0*/) {
196
+void MarlinUI::goto_screen(screenFunc_t screen, const uint16_t encoder/*=0*/, const uint8_t top/*=0*/, const uint8_t items/*=0*/) {
197 197
   if (currentScreen != screen) {
198 198
 
199 199
     #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
@@ -364,7 +364,7 @@ void MarlinUI::completion_feedback(const bool good/*=true*/) {
364 364
     #endif
365 365
     ui.encoder_direction_normal();
366 366
     if (ui.encoderPosition) {
367
-      const int16_t babystep_increment = (int32_t)ui.encoderPosition * (BABYSTEP_MULTIPLICATOR);
367
+      const int16_t babystep_increment = int16_t(ui.encoderPosition) * (BABYSTEP_MULTIPLICATOR);
368 368
       ui.encoderPosition = 0;
369 369
 
370 370
       const float diff = planner.steps_to_mm[Z_AXIS] * babystep_increment,
@@ -438,7 +438,7 @@ void _lcd_draw_homing() {
438 438
 
439 439
 void do_select_screen(PGM_P const yes, PGM_P const no, bool &yesno, PGM_P const pref, const char * const string, PGM_P const suff) {
440 440
   if (ui.encoderPosition) {
441
-    yesno = int32_t(ui.encoderPosition) > 0;
441
+    yesno = int16_t(ui.encoderPosition) > 0;
442 442
     ui.encoderPosition = 0;
443 443
   }
444 444
   draw_select_screen(yes, no, yesno, pref, string, suff);

+ 13
- 7
Marlin/src/lcd/menu/menu.h View File

@@ -156,10 +156,16 @@ class MenuItem_function {
156 156
 ////////////////////////////////////////////
157 157
 
158 158
 class MenuItemBase {
159
+  private:
160
+    static PGM_P editLabel;
161
+    static void *editValue;
162
+    static int16_t minEditValue, maxEditValue;
163
+    static screenFunc_t callbackFunc;
164
+    static bool liveEdit;
159 165
   protected:
160
-    typedef char* (*strfunc_t)(const int32_t);
161
-    typedef void (*loadfunc_t)(void *, const int32_t);
162
-    static void init(PGM_P const el, void * const ev, const int32_t minv, const int32_t maxv, const uint32_t ep, const screenFunc_t cs, const screenFunc_t cb, const bool le);
166
+    typedef char* (*strfunc_t)(const int16_t);
167
+    typedef void (*loadfunc_t)(void *, const int16_t);
168
+    static void init(PGM_P const el, void * const ev, const int16_t minv, const int16_t maxv, const uint16_t ep, const screenFunc_t cs, const screenFunc_t cb, const bool le);
163 169
     static void edit(strfunc_t, loadfunc_t);
164 170
 };
165 171
 
@@ -169,12 +175,12 @@ class TMenuItem : MenuItemBase {
169 175
     typedef typename NAME::type_t type_t;
170 176
     static inline float unscale(const float value)    { return value * (1.0f / NAME::scale);  }
171 177
     static inline float scale(const float value)      { return value * NAME::scale;           }
172
-    static void  load(void *ptr, const int32_t value) { *((type_t*)ptr) = unscale(value);     }
173
-    static char* to_string(const int32_t value)       { return NAME::strfunc(unscale(value)); }
178
+    static void load(void *ptr, const int16_t value)  { *((type_t*)ptr) = unscale(value);     }
179
+    static char* to_string(const int16_t value)       { return NAME::strfunc(unscale(value)); }
174 180
   public:
175 181
     static void action_edit(PGM_P const pstr, type_t * const ptr, const type_t minValue, const type_t maxValue, const screenFunc_t callback=NULL, const bool live=false) {
176
-      const int32_t minv = scale(minValue);
177
-      init(pstr, ptr, minv, int32_t(scale(maxValue)) - minv, int32_t(scale(*ptr)) - minv, edit, callback, live);
182
+      const int16_t minv = scale(minValue);
183
+      init(pstr, ptr, minv, int16_t(scale(maxValue)) - minv, int16_t(scale(*ptr)) - minv, edit, callback, live);
178 184
     }
179 185
     static void edit() { MenuItemBase::edit(to_string, load); }
180 186
 };

+ 1
- 1
Marlin/src/lcd/menu/menu_bed_leveling.cpp View File

@@ -120,7 +120,7 @@
120 120
     // Encoder knob or keypad buttons adjust the Z position
121 121
     //
122 122
     if (ui.encoderPosition) {
123
-      const float z = current_position[Z_AXIS] + float((int32_t)ui.encoderPosition) * (MESH_EDIT_Z_STEP);
123
+      const float z = current_position[Z_AXIS] + float(int16_t(ui.encoderPosition)) * (MESH_EDIT_Z_STEP);
124 124
       line_to_z(constrain(z, -(LCD_PROBE_Z_RANGE) * 0.5f, (LCD_PROBE_Z_RANGE) * 0.5f));
125 125
       ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
126 126
       ui.encoderPosition = 0;

+ 3
- 3
Marlin/src/lcd/menu/menu_mixer.cpp View File

@@ -44,7 +44,7 @@
44 44
     ui.encoder_direction_normal();
45 45
     ENCODER_RATE_MULTIPLY(true);
46 46
     if (ui.encoderPosition != 0) {
47
-      mixer.gradient.start_z += float((int)ui.encoderPosition) * 0.1;
47
+      mixer.gradient.start_z += float(int16_t(ui.encoderPosition)) * 0.1;
48 48
       ui.encoderPosition = 0;
49 49
       NOLESS(mixer.gradient.start_z, 0);
50 50
       NOMORE(mixer.gradient.start_z, Z_MAX_POS);
@@ -69,7 +69,7 @@
69 69
     ui.encoder_direction_normal();
70 70
     ENCODER_RATE_MULTIPLY(true);
71 71
     if (ui.encoderPosition != 0) {
72
-      mixer.gradient.end_z += float((int)ui.encoderPosition) * 0.1;
72
+      mixer.gradient.end_z += float(int16_t(ui.encoderPosition)) * 0.1;
73 73
       ui.encoderPosition = 0;
74 74
       NOLESS(mixer.gradient.end_z, 0);
75 75
       NOMORE(mixer.gradient.end_z, Z_MAX_POS);
@@ -185,7 +185,7 @@ void lcd_mixer_mix_edit() {
185 185
   #elif DUAL_MIXING_EXTRUDER
186 186
 
187 187
     if (ui.encoderPosition != 0) {
188
-      mixer.mix[0] += (int)ui.encoderPosition;
188
+      mixer.mix[0] += int16_t(ui.encoderPosition);
189 189
       ui.encoderPosition = 0;
190 190
       if (mixer.mix[0] < 0) mixer.mix[0] += 101;
191 191
       if (mixer.mix[0] > 100) mixer.mix[0] -= 101;

+ 4
- 4
Marlin/src/lcd/menu/menu_motion.cpp View File

@@ -121,16 +121,16 @@ static void _lcd_move_xyz(PGM_P name, AxisEnum axis) {
121 121
     #endif
122 122
 
123 123
     // Get the new position
124
-    const float diff = float((int32_t)ui.encoderPosition) * move_menu_scale;
124
+    const float diff = float(int16_t(ui.encoderPosition)) * move_menu_scale;
125 125
     #if IS_KINEMATIC
126 126
       manual_move_offset += diff;
127
-      if ((int32_t)ui.encoderPosition < 0)
127
+      if (int16_t(ui.encoderPosition) < 0)
128 128
         NOLESS(manual_move_offset, min - current_position[axis]);
129 129
       else
130 130
         NOMORE(manual_move_offset, max - current_position[axis]);
131 131
     #else
132 132
       current_position[axis] += diff;
133
-      if ((int32_t)ui.encoderPosition < 0)
133
+      if (int16_t(ui.encoderPosition) < 0)
134 134
         NOLESS(current_position[axis], min);
135 135
       else
136 136
         NOMORE(current_position[axis], max);
@@ -161,7 +161,7 @@ static void _lcd_move_e(
161 161
   ui.encoder_direction_normal();
162 162
   if (ui.encoderPosition) {
163 163
     if (!ui.processing_manual_move) {
164
-      const float diff = float((int32_t)ui.encoderPosition) * move_menu_scale;
164
+      const float diff = float(int16_t(ui.encoderPosition)) * move_menu_scale;
165 165
       #if IS_KINEMATIC
166 166
         manual_move_offset += diff;
167 167
       #else

+ 9
- 5
Marlin/src/lcd/menu/menu_sdcard.cpp View File

@@ -47,10 +47,11 @@ void lcd_sd_updir() {
47 47
 
48 48
 #if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
49 49
 
50
-  uint32_t last_sdfile_encoderPosition = 0xFFFF;
50
+  uint16_t sd_encoder_position = 0xFFFF;
51
+  int8_t sd_top_line, sd_items;
51 52
 
52 53
   void MarlinUI::reselect_last_file() {
53
-    if (last_sdfile_encoderPosition == 0xFFFF) return;
54
+    if (sd_encoder_position == 0xFFFF) return;
54 55
     //#if HAS_GRAPHICAL_LCD
55 56
     //  // This is a hack to force a screen update.
56 57
     //  ui.refresh(LCDVIEW_CALL_REDRAW_NEXT);
@@ -61,8 +62,8 @@ void lcd_sd_updir() {
61 62
     //  ui.drawing_screen = screen_changed = true;
62 63
     //#endif
63 64
 
64
-    goto_screen(menu_sdcard, last_sdfile_encoderPosition);
65
-    last_sdfile_encoderPosition = 0xFFFF;
65
+    goto_screen(menu_sdcard, sd_encoder_position, sd_top_line, sd_items);
66
+    sd_encoder_position = 0xFFFF;
66 67
 
67 68
     defer_status_screen();
68 69
 
@@ -99,7 +100,10 @@ class MenuItem_sdfile {
99 100
   public:
100 101
     static void action(CardReader &theCard) {
101 102
       #if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
102
-        last_sdfile_encoderPosition = ui.encoderPosition;  // Save which file was selected for later use
103
+        // Save menu state for the selected file
104
+        sd_encoder_position = ui.encoderPosition;
105
+        sd_top_line = ui.encoderTopLine;
106
+        sd_items = ui.screen_items;
103 107
       #endif
104 108
       #if ENABLED(SD_MENU_CONFIRM_START)
105 109
         do_print_file = false;

+ 1
- 1
Marlin/src/lcd/menu/menu_tune.cpp View File

@@ -75,7 +75,7 @@
75 75
     if (ui.use_click()) return ui.goto_previous_screen_no_defer();
76 76
     ui.encoder_direction_normal();
77 77
     if (ui.encoderPosition) {
78
-      const int16_t steps = (int32_t)ui.encoderPosition * (BABYSTEP_MULTIPLICATOR);
78
+      const int16_t steps = int16_t(ui.encoderPosition) * (BABYSTEP_MULTIPLICATOR);
79 79
       ui.encoderPosition = 0;
80 80
       ui.refresh(LCDVIEW_REDRAW_NOW);
81 81
       babystep.add_steps(axis, steps);

+ 1
- 1
Marlin/src/lcd/menu/menu_ubl.cpp View File

@@ -471,7 +471,7 @@ void _lcd_ubl_output_map_lcd() {
471 471
   ui.encoder_direction_normal();
472 472
 
473 473
   if (ui.encoderPosition) {
474
-    step_scaler += (int32_t)ui.encoderPosition;
474
+    step_scaler += int16_t(ui.encoderPosition);
475 475
     x_plot += step_scaler / (ENCODER_STEPS_PER_MENU_ITEM);
476 476
     ui.encoderPosition = 0;
477 477
     ui.refresh(LCDVIEW_REDRAW_NOW);

+ 4
- 4
Marlin/src/lcd/ultralcd.cpp View File

@@ -118,7 +118,7 @@ millis_t next_button_update_ms;
118 118
 
119 119
 // Encoder Handling
120 120
 #if HAS_ENCODER_ACTION
121
-  uint32_t MarlinUI::encoderPosition;
121
+  uint16_t MarlinUI::encoderPosition;
122 122
   volatile int8_t encoderDiff; // Updated in update_buttons, added to encoderPosition every LCD update
123 123
 #endif
124 124
 
@@ -480,13 +480,13 @@ void MarlinUI::status_screen() {
480 480
   #if ENABLED(ULTIPANEL_FEEDMULTIPLY)
481 481
 
482 482
     const int16_t old_frm = feedrate_percentage;
483
-          int16_t new_frm = old_frm + (int32_t)encoderPosition;
483
+          int16_t new_frm = old_frm + int16_t(encoderPosition);
484 484
 
485 485
     // Dead zone at 100% feedrate
486 486
     if (old_frm == 100) {
487
-      if ((int32_t)encoderPosition > ENCODER_FEEDRATE_DEADZONE)
487
+      if (int16_t(encoderPosition) > ENCODER_FEEDRATE_DEADZONE)
488 488
         new_frm -= ENCODER_FEEDRATE_DEADZONE;
489
-      else if ((int32_t)encoderPosition < -(ENCODER_FEEDRATE_DEADZONE))
489
+      else if (int16_t(encoderPosition) < -(ENCODER_FEEDRATE_DEADZONE))
490 490
         new_frm += ENCODER_FEEDRATE_DEADZONE;
491 491
       else
492 492
         new_frm = old_frm;

+ 2
- 2
Marlin/src/lcd/ultralcd.h View File

@@ -421,7 +421,7 @@ public:
421 421
     static void synchronize(PGM_P const msg=NULL);
422 422
 
423 423
     static screenFunc_t currentScreen;
424
-    static void goto_screen(const screenFunc_t screen, const uint32_t encoder=0, const uint8_t top=0, const uint8_t items=0);
424
+    static void goto_screen(const screenFunc_t screen, const uint16_t encoder=0, const uint8_t top=0, const uint8_t items=0);
425 425
     static void save_previous_screen();
426 426
     static void goto_previous_screen();
427 427
     static void return_to_status();
@@ -496,7 +496,7 @@ public:
496 496
       static void wait_for_release();
497 497
     #endif
498 498
 
499
-    static uint32_t encoderPosition;
499
+    static uint16_t encoderPosition;
500 500
 
501 501
     #if ENABLED(REVERSE_ENCODER_DIRECTION)
502 502
       #define ENCODERBASE -1

Loading…
Cancel
Save