screen_photomode_save.c File Reference

#include "screen_photomode_save.h"
#include "filesystem.h"
#include "button.h"
#include "tft.h"
#include "touch.h"
#include "pixy.h"
#include "pixy_frame.h"
#include <stdlib.h>
#include <string.h>

Include dependency graph for screen_photomode_save.c:

Go to the source code of this file.

Data Structures
struct	FILE_LIST_ENTRY_S

Macros
#define	X_OFS   5

Typedefs
typedef struct FILE_LIST_ENTRY_S	FILE_LIST_ENTRY

Enumerations
enum	{   init, error, showlist, picking,   saving, done }

Functions
static void	b_back_cb (void *button)
static void	touchCB (void *touchArea, TOUCH_ACTION triggeredAction)
static void	enter (void *screen)
static void	update (void *screen)
static void	leave (void *screen)
SCREEN_STRUCT *	get_screen_photomodesave ()

Variables
static BUTTON_STRUCT	b_back
static TOUCH_AREA_STRUCT	a_area
static int	num_files_ok
static enum { ... }	state
static int	fontheight
static int	liststart
static const char *	picked_file
static FILE_LIST_ENTRY *	files_ok
static const char *	nomatch_text []
static unsigned char	bmpheader_data [0x7A]
static SCREEN_STRUCT	screen

Macro Definition Documentation

#define X_OFS   5

Typedef Documentation

typedef struct FILE_LIST_ENTRY_S FILE_LIST_ENTRY

Enumeration Type Documentation

anonymous enum

Enumerator
init
error
showlist
picking
saving
done

Definition at line 36 of file screen_photomode_save.c.

{init, error, showlist, picking, saving, done} state; //Current state of the screen state machine

Function Documentation

static void b_back_cb ( void *  button )

static

Definition at line 30 of file screen_photomode_save.c.

{
    gui_screen_back();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void enter ( void *  screen )

static

Definition at line 108 of file screen_photomode_save.c.

{
    tft_clear(WHITE);


#define X_OFS 5

    //Back button
    b_back.base.x1 = X_OFS; //Start X of Button
    b_back.base.y1 = 210; //Start Y of Button
    b_back.base.x2 = AUTO; //Auto Calculate X2 with String Width
    b_back.base.y2 = AUTO; //Auto Calculate Y2 with String Height
    b_back.txtcolor = WHITE; //Set foreground color
    b_back.bgcolor = HEX(0xAE1010); //Set background color (Don't take 255 or 0 on at least one channel, to make shadows possible)
    b_back.font = 0; //Select Font
    b_back.text = "Back"; //Set Text (For formatted strings take sprintf)
    b_back.callback = b_back_cb; //Call b_back_cb as Callback
    gui_button_add(&b_back); //Register Button (and run the callback from now on)

    state = init; //Start with the init state
    fontheight = tft_font_height(0) + 2; //Save the height of the used font, for fast access
    files_ok = NULL; //initialize the linked list with 0 elements
    num_files_ok = 0; //we have zero! elements
}

Here is the call graph for this function:

static void leave ( void *  screen )

static

Definition at line 310 of file screen_photomode_save.c.

{
    gui_button_remove(&b_back); //Remove/Free the back button

    if (state == picking) { //The user left the screen in the "picking"-phase
        touch_unregister_area(&a_area); //remove the touch area (for the list)
    }

    if (state == picking || state == saving || state == done) { //the user left the screen after we created the linked list
        //Iterate through the linked list and free all resources
        FILE_LIST_ENTRY* current_entry = files_ok; //start with the list head

        while (current_entry != NULL) { //while we're not at the end
            FILE_LIST_ENTRY* temp = current_entry->next; //save the next pointer because we free the current element on the next line
            free((void*)(current_entry->filename)); //free filename
            free(current_entry); //free element itself
            current_entry = temp; //advance
        }
    }
}

Here is the call graph for this function:

static void touchCB ( void *  touchArea, TOUCH_ACTION  triggeredAction  )

static

Definition at line 50 of file screen_photomode_save.c.

{

    int y = touch_get_last_point().y - liststart; //Calculate the y-Coordinate of the touch point relative to the start of the file-list
    int elem = y / fontheight; //Calculate the file index

    if (elem < 0 | elem >= num_files_ok) {
        return;    //Check if the file index is valid  (0,1,..,num_files_ok-1)
    }

    //Search for the corresponding entry in the linked list
    FILE_LIST_ENTRY* current_entry = files_ok; //Start walking through the list, starting by the head of the list

    for (int i = 0; i < elem; i++) { //Until we have reached the file (index)
        current_entry = current_entry->next; //traverse to the next file
    }

    picked_file = current_entry->filename; //save the picked filename. It will be used by the statemachine in the main loop
    touch_unregister_area(&a_area); //unregister the touch area, we no longer need it. No more interrupts will be fired.
    state = saving; //Change the state of the  statemachine
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void update ( void *  screen )

static

Definition at line 135 of file screen_photomode_save.c.

{
    switch (state) {
    case init: { //Init State: The user just entered the screen
        DIRECTORY_STRUCT* dir = filesystem_dir_open("."); //open root directory

        if (dir == NULL) { //error while opening root directory
            tft_print_line(X_OFS, 5, BLACK, TRANSPARENT, 0, "Error accessing Filesystem");
            state = error;
            break;
        }

        bool nomatch = true; //whether or not we have zero files which are suitable for saving

        for (int i = 0; i < dir->num_files; i++) { //walk through all files in the directory
            FILE_STRUCT* file = &(dir->files[i]); //Pointer to the current file/subdirectory

            //Ignore directories, archives, hidden files, system files and files we cannot write to
            if (file->fattrib & (F_SYS | F_HID | F_ARC | F_DIR | F_RDO)) {
                continue;
            }

            //ignore files which are not large enough
            if (file->fsize < 189410) {
                continue;    //size taken from an example bitmap (318x198x24)
            }

            nomatch = false; //at least one file matches
            break;
        }

        if (nomatch) { //not one file is suitable for writing
            int y = 5; //y-Coordinate where to start writing the error text
            int i = 0;

            while (nomatch_text[i] != NULL) { //for every line in the big error array
                //Write the line's text and go to the next line
                tft_print_line(X_OFS, y + i * fontheight, BLACK, TRANSPARENT, 0, nomatch_text[i]);
                i++;
            }

            state = error;
        } else { //we have a least one suitable file
            state = showlist;
        }

        filesystem_dir_close(dir); //free directory struct
    }
    break;

    case showlist: { //Show List State: Where we load and present the suitable file's to the user in a list
        DIRECTORY_STRUCT* dir2 = filesystem_dir_open("."); //Open the directory again

        if (dir2 == NULL) {
            return;    //Error on opening? This should never happen, since it's handled in the previous state
        }

        int y = 5; //y-Coordinate where to start drawing/writing text/list-elements

        tft_print_line(X_OFS, y, BLACK, TRANSPARENT, 0, "Pick a file to save the image to");
        y += fontheight + 5;

        tft_print_line(X_OFS, y, BLUE, TRANSPARENT, 0, "Name             Modified          Size");
        y += fontheight;

        liststart = y; //store the y coordinate of the start of the list away (used in toucharea callback)
        num_files_ok = 0; //we start with 0 matching files

        FILE_LIST_ENTRY* current_entry = NULL; //We start with an empty list

        for (int i = 0; i < dir2->num_files && num_files_ok < 10; i++) { //go through all the files of the directory, abort if we have 10 matches
            FILE_STRUCT* file = &(dir2->files[i]);

            //Ignore directories, archives, hidden files, system files and files we cannot write to
            if (file->fattrib & (F_SYS | F_HID | F_ARC | F_DIR | F_RDO)) {
                continue;
            }

            //ignore files which are not large enough
            if (file->fsize < 189410) {
                continue;    //size taken from an example bitmap (318x198x24)
            }

            //Print out filename, modified date,time and file size
            tft_print_formatted(X_OFS, y, BLACK,
                                TRANSPARENT, 0, "%-16s %02u.%02u.%02u %02u:%02u:%02u %u",
                                file->fname,
                                file->fdate.day,
                                file->fdate.month,
                                (file->fdate.year + 1980) % 100,
                                file->ftime.hour,
                                file->ftime.min,
                                file->ftime.sec * 2,
                                file->fsize);

            if (current_entry == NULL) { //The list is empty
                current_entry = malloc(sizeof(FILE_LIST_ENTRY)); //create new entry
                files_ok = current_entry; //assign it to the list head
            } else { //there's a least one entry in the list
                current_entry->next = malloc(sizeof(FILE_LIST_ENTRY)); //append entry to previous entry
                current_entry = current_entry->next; //newly created entry is the current now.
            }

            current_entry->next = NULL; //we're at the end of the list (for now)
            current_entry->filename = malloc(strlen(file->fname) + 1); //allocate space for the filename + zero-termination
            strcpy(current_entry->filename, file->fname); //copy filename (so that we can close the directory after scanning)

            //since we have found a suitable file we need to increment the position in the list
            num_files_ok++;
            y += fontheight;
        }

        //Touch area for file-selection (in the list)
        a_area.hookedActions = PEN_UP; //we're only interested in PEN_UP events
        a_area.x1 = X_OFS; //Left border
        a_area.y1 = liststart; //Start where the list started
        a_area.x2 = 320 - X_OFS; //Right border
        a_area.y2 = liststart + fontheight * num_files_ok; //stop at the end of the list
        a_area.callback = touchCB; //execute our callback when PEN_UP occurs
        touch_register_area(&a_area); //register the touch area and receive events from now on

        filesystem_dir_close(dir2); //we no longer need the directory struct, since we have our own linked list now

        state = picking;
    }
    break;

    case picking: //Picking State: Where we wait on the users file choice
        pixy_service(); //Handle pending pixy events
        //do nothing and wait on user to pick a file
        break;

    case saving: { //Saving State: Where we save the image to the selected file
        FILE_HANDLE* file = filesystem_file_open(picked_file); //try to open the selected file

        if (file == NULL) { //opening the file failed
            tft_print_formatted(X_OFS, 190, BLUE, TRANSPARENT, 0, "Could not open %s", picked_file);
            state = error;
            break;
        }

        filesystem_file_seek(file, 0); //seek to the start of the file (optional?)

        if (filesystem_file_write(file, bmpheader_data, 0x7A) != F_OK) { //Writing the header failed
            tft_print_formatted(X_OFS, 190, BLUE, TRANSPARENT, 0, "Error while writing to %s", picked_file);
            filesystem_file_close(file);
            state = error;
            break;
        }

        if (pixy_save_full_frame(file) != 0) { //Writing the imagedata failed
            tft_print_formatted(X_OFS, 190, BLUE, TRANSPARENT, 0, "Error while writing to %s", picked_file);
            filesystem_file_close(file);
            state = error;
            break;
        }

        //if we reach this point, we have written all data out successfully

        filesystem_file_close(file); //close/finalize the file
        tft_print_formatted(X_OFS, 190, BLUE, TRANSPARENT, 0, "Image saved to %s", picked_file);
        state = done;
    }
    break;

    case error: //Error State: Where we show an error message and leave the user no other choice than to click the backbutton
    case done: //Done State: When saving the file was successful
        pixy_service(); //Handle pending pixy events
        //wait on user to click the back button
        break;

    }
}

Here is the call graph for this function:

Variable Documentation

TOUCH_AREA_STRUCT a_area

static

Definition at line 27 of file screen_photomode_save.c.

BUTTON_STRUCT b_back

static

Definition at line 26 of file screen_photomode_save.c.

unsigned char bmpheader_data[0x7A]

static

Initial value:

= {
    0x42, 0x4d, 0xe2, 0xe3, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0x00,
    0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x3e, 0x01, 0x00, 0x00, 0xc6, 0x00,
    0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xe3,
    0x02, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x47, 0x52, 0x73, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00
}

Definition at line 93 of file screen_photomode_save.c.

FILE_LIST_ENTRY* files_ok

static

Definition at line 47 of file screen_photomode_save.c.

int fontheight

static

Definition at line 37 of file screen_photomode_save.c.

int liststart

static

Definition at line 38 of file screen_photomode_save.c.

const char* nomatch_text[]

static

Initial value:

= {
    "Due to limitations of the filesystem",
    "implementation you can only write to",
    "existing files.",
    "",
    "The files need to have a .bmp",
    "extension and must be at least",
    "189410 bytes (185kb) large.",
    "Unfortunately there were no such",
    "files found in the root directory.",
    "",
    "Please create some files and come",
    "back again.",
    NULL
}

Definition at line 73 of file screen_photomode_save.c.

int num_files_ok

static

Definition at line 35 of file screen_photomode_save.c.

const char* picked_file

static

Definition at line 39 of file screen_photomode_save.c.

SCREEN_STRUCT screen

static

Initial value:

= {
    enter,
    leave,
    update
}

Definition at line 332 of file screen_photomode_save.c.

enum { ... } state