screen_mesh_bed_lv.cpp File Reference

#include "gui.h"
#include "config.h"
#include "status_footer.h"
#include "math.h"
#include "marlin_client.h"

Classes
struct	screen_mesh_bed_lv_data_t

Macros
#define	pd   ((screen_mesh_bed_lv_data_t *)screen->pdata)
#define	btnMeshStrings_sz   (sizeof(btnMeshStrings) / sizeof(const char *))
#define	meshStrings_sz   (sizeof(meshStrings) / sizeof(const char *))
#define	MESH_DEFAULT_CL   COLOR_WHITE
#define	MESH_ACTIVE_CL   COLOR_RED

Enumerations
enum	mesh_state_t {   MS_idle, MS_home, MS_homeing, MS_homed,   MS_mesh, MS_meshing, MS_meshed }
enum	{ TAG_QUIT = 10, TAG_MESH }

Functions
static void	gui_state_mesh_off (screen_t *screen)
static void	gui_state_mesh_on (screen_t *screen)
void	screen_mesh_bed_lv_init (screen_t *screen)
void	screen_mesh_bed_lv_done (screen_t *screen)
void	screen_mesh_bed_lv_draw (screen_t *screen)
int	screen_mesh_bed_lv_event (screen_t *screen, window_t *window, uint8_t event, void *param)

Variables
const char *	btnMeshStrings [] = { "Run mesh", "Mesh in progress" }
const char *	meshStrings [] = { "Mesh not in failed state", "Mesh in failed state" }
screen_t	screen_mesh_bed_lv
const screen_t *	pscreen_mesh_bed_lv = &screen_mesh_bed_lv

Macro Definition Documentation

pd

#define pd   ((screen_mesh_bed_lv_data_t *)screen->pdata)

btnMeshStrings_sz

#define btnMeshStrings_sz   (sizeof(btnMeshStrings) / sizeof(const char *))

meshStrings_sz

#define meshStrings_sz   (sizeof(meshStrings) / sizeof(const char *))

MESH_DEFAULT_CL

#define MESH_DEFAULT_CL   COLOR_WHITE

MESH_ACTIVE_CL

#define MESH_ACTIVE_CL   COLOR_RED

Enumeration Type Documentation

mesh_state_t

enum mesh_state_t

Enumerator
MS_idle
MS_home
MS_homeing
MS_homed
MS_mesh
MS_meshing
MS_meshed

             {
    MS_idle,
    MS_home,
    MS_homeing,
    MS_homed,
    MS_mesh,
    MS_meshing,
    MS_meshed //,
    //MS_done
} mesh_state_t;

anonymous enum

anonymous enum

Enumerator
TAG_QUIT
TAG_MESH

     {
    TAG_QUIT = 10,
    TAG_MESH
 
};

Function Documentation

gui_state_mesh_off()

static void gui_state_mesh_off ( screen_t *  screen )

static

                                                 {
    //if (pd->mesh_bt_id == -1)return;
    //if (pd->exit_bt_id == -1)return;
    window_set_color_text(pd->mesh_bt_id, MESH_DEFAULT_CL);
    window_set_text(pd->mesh_bt_id, btnMeshStrings[0]);
    window_set_color_text(pd->exit_bt_id, MESH_DEFAULT_CL);
    window_enable(pd->exit_bt_id);
    window_enable(pd->mesh_bt_id);
    //pd->mesh_state = MS_idle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gui_state_mesh_on()

static void gui_state_mesh_on ( screen_t *  screen )

static

                                                {
    window_disable(pd->exit_bt_id);
    window_set_color_text(pd->exit_bt_id, MESH_ACTIVE_CL);
    window_disable(pd->mesh_bt_id);
    window_set_text(pd->mesh_bt_id, btnMeshStrings[1]);
    window_set_color_text(pd->mesh_bt_id, MESH_ACTIVE_CL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

screen_mesh_bed_lv_init()

void screen_mesh_bed_lv_init

(

screen_t *

screen

)

                                               {
    pd->mesh_state = MS_idle;
    pd->exit_bt_id = -1;
    pd->mesh_bt_id = -1;
 
    int16_t id;
    uint16_t row_h = 25;
 
    int16_t id0 = window_create_ptr(WINDOW_CLS_FRAME,
        -1, rect_ui16(0, 0, 0, 0), &(pd->frame));
 
    id = window_create_ptr(WINDOW_CLS_TEXT,
        id0, rect_ui16(0, 0, display->w, row_h), &(pd->textMenuName));
    pd->textMenuName.font = resource_font(IDR_FNT_BIG);
    window_set_text(id, (const char *)"MESH LEVELING");
 
    id = window_create_ptr(WINDOW_CLS_TEXT,
        id0, rect_ui16(2, 50, 200, row_h), &(pd->btMesh));
    window_set_text(id, btnMeshStrings[0]);
    window_enable(id);
    window_set_tag(id, TAG_MESH);
 
    id = window_create_ptr(WINDOW_CLS_TEXT,
        id0, rect_ui16(2, 75, 200, row_h),
        &(pd->text_mesh_state));
 
    //terminal
    id = window_create_ptr(WINDOW_CLS_TERM, id0, rect_ui16(10, 28, 11 * 20, 18 * 16), &(pd->term));
    pd->id_term = id;
    term_init(&(pd->terminal), 20, 16, pd->term_buff);
    pd->term.term = &(pd->terminal);
 
    //exit and footer
 
    id = window_create_ptr(WINDOW_CLS_TEXT,
        id0, rect_ui16(2, 245, 60, 22), &(pd->textExit));
    pd->textExit.font = resource_font(IDR_FNT_BIG);
    window_set_text(id, (const char *)"EXIT");
    window_enable(id);
    window_set_tag(id, TAG_QUIT);
    pd->exit_bt_id = id;
 
    status_footer_init(&(pd->footer), id0);
}

Here is the call graph for this function:

screen_mesh_bed_lv_done()

void screen_mesh_bed_lv_done

(

screen_t *

screen

)

                                               {
    window_destroy(pd->frame.win.id);
}

Here is the call graph for this function:

screen_mesh_bed_lv_draw()

void screen_mesh_bed_lv_draw

(

screen_t *

screen

)

                                               {
}

screen_mesh_bed_lv_event()

int screen_mesh_bed_lv_event	(	screen_t *	screen,
		window_t *	window,
		uint8_t	event,
		void *	param
	)

                                                                                             {
    if (status_footer_event(&(pd->footer), window, event, param)) {
        return 1;
    }
 
    status_footer_event(&(pd->footer), window, event, param);
    if (event == WINDOW_EVENT_CLICK)
        switch ((int)param) {
        case TAG_QUIT:
            if (pd->mesh_state != MS_idle)
                return 0; //button should not be accessible
            screen_close();
            return 1;
 
        case TAG_MESH:
            if (pd->mesh_state == MS_idle) {
                gui_state_mesh_on(screen);
                pd->mesh_state = MS_home;
            }
            break;
        }
    if (event == WINDOW_EVENT_CHANGE) {
        switch ((int)param) {
        case TAG_MESH:
            break;
        }
    }
    if (event == WINDOW_EVENT_LOOP) {
        if (marlin_error(MARLIN_ERR_ProbingFailed)) {
            window_set_text(pd->text_mesh_state.win.id, meshStrings[1]);
        } else {
            window_set_text(pd->text_mesh_state.win.id, meshStrings[0]);
        }
        switch (pd->mesh_state) {
        case MS_idle:
            //do nothing
            break;
        case MS_home:
            marlin_error_clr(MARLIN_ERR_ProbingFailed);
            marlin_gcode_printf("G28");
            pd->mesh_state = MS_homeing;
            break;
        case MS_homeing:
            if (marlin_event(MARLIN_EVT_Ready)) {
                pd->mesh_state = MS_homed;
                marlin_event_clr(MARLIN_EVT_Ready);
            }
            break;
        case MS_homed:
            pd->mesh_state = MS_mesh;
            //there is no break;
        case MS_mesh:
            marlin_gcode_printf("G29");
            pd->mesh_state = MS_meshing;
            break;
        case MS_meshing:
            if (marlin_event(MARLIN_EVT_Ready)) {
                pd->mesh_state = MS_meshed;
                marlin_event_clr(MARLIN_EVT_Ready);
            }
            break;
        case MS_meshed:
            gui_state_mesh_off(screen);
            pd->mesh_state = MS_idle;
            break;
        }
    }
 
    return 0;
}

Here is the call graph for this function:

Variable Documentation

btnMeshStrings

const char* btnMeshStrings[] = { "Run mesh", "Mesh in progress" }

meshStrings

const char* meshStrings[] = { "Mesh not in failed state", "Mesh in failed state" }

screen_mesh_bed_lv

screen_t screen_mesh_bed_lv

Initial value:

= {
    0,
    0,
    screen_mesh_bed_lv_init,
    screen_mesh_bed_lv_done,
    screen_mesh_bed_lv_draw,
    screen_mesh_bed_lv_event,
    sizeof(screen_mesh_bed_lv_data_t), 
    0, 
}

pscreen_mesh_bed_lv

const screen_t* pscreen_mesh_bed_lv = &screen_mesh_bed_lv