script.c-Dateireferenz

#include "camera_info.h"
#include "keyboard.h"
#include "modes.h"
#include "viewport.h"
#include "conf.h"
#include "script.h"
#include "console.h"
#include "action_stack.h"
#include "shot_histogram.h"
#include "lang.h"
#include "gui.h"
#include "gui_lang.h"
#include "ptp.h"
#include "clock.h"
#include "usb_remote.h"
#include "script_api.h"
#include "motion_detector.h"

Include-Abhängigkeitsdiagramm für script.c:

gehe zum Quellcode dieser Datei

Funktionen
void	script_end ()
static void	script_print_screen_init ()
static void	script_print_screen_end ()
void	script_print_screen_statement (int val)
void	script_console_add_line (long str_id)
void	script_console_add_error (long str_id)
static int	action_stack_AS_SCRIPT_RUN ()
long	script_stack_start ()
int	script_is_running ()
void	script_set_terminate_key (int key, const char *keyname)
void	script_get_alt_text (char *buf)
void	script_check_terminate (void)
static int	gui_script_kbd_process ()
void	gui_script_draw ()
void	script_wait_terminate (void)
long	script_start_gui (int autostart)

Variablen
static AS_ID	running_script_stack_name = 0
static int	script_terminate_key = KEY_SHOOT_FULL
static char	script_terminate_key_name [20]
static int	script_terminate_request = 0
static int	print_screen_p
static int	print_screen_d = -1
char	print_screen_file [25]
gui_handler	scriptGuiHandler = { GUI_MODE_SCRIPT, gui_script_draw, gui_script_kbd_process, 0, 0, 0 }
static gui_handler *	old_gui_handler = 0

Dokumentation der Funktionen

static int action_stack_AS_SCRIPT_RUN ( )

static

Definiert in Zeile 105 der Datei script.c.

{
    if (camera_info.state.state_kbd_script_run)
    {
        int rv = libscriptapi->script_run();
        if (rv != SCRIPT_RUN_RUNNING)
        {
            // Script language is responsible for displaying 'Finished' or error
            // messages so all we need to do is shutdown the script engine
            script_end();
            return 1;
        }
    }
    else
    {
        action_pop_func(0);
        return 1;
    }
    return 0;
}

void gui_script_draw

(

)

Definiert in Zeile 192 der Datei script.c.

{
    extern void gui_chdk_draw();
    gui_chdk_draw();

    if (camera_info.state.mode_rec || camera_info.state.mode_play)
    {
        static int show_md_grid=0;
        if (camera_info.state.state_kbd_script_run) show_md_grid=5;
        if (show_md_grid)
        {
            --show_md_grid;
            libmotiondetect->md_draw_grid();
        }
    }
}

static int gui_script_kbd_process ( )

static

Definiert in Zeile 172 der Datei script.c.

{
    // Stop a script if the shutter button pressed in Script mode
    if (kbd_is_key_clicked(script_terminate_key))
    {
        script_console_add_error(LANG_CONSOLE_TEXT_INTERRUPTED);
        if (camera_info.state.state_kbd_script_run == SCRIPT_STATE_INTERRUPTED)
            script_end();
        else
        {
            camera_info.state.state_kbd_script_run = SCRIPT_STATE_INTERRUPTED;
            if (libscriptapi->run_restore() == 0)
                script_end();
        }
    }

    return 0;
}

void script_check_terminate

(

void

)

Definiert in Zeile 162 der Datei script.c.

{
    if(camera_info.state.state_kbd_script_run && script_terminate_request) {
        script_console_add_error(LANG_CONSOLE_TEXT_TERMINATED);
        script_end();
    }
}

void script_console_add_error

(

long

str_id)

Definiert in Zeile 94 der Datei script.c.

{
    console_set_autoredraw(1);          // Force console display on
    script_console_add_line(str_id);
}

void script_console_add_line

(

long

str_id)

Definiert in Zeile 81 der Datei script.c.

{
    const char* str = lang_str(str_id);
    console_add_line(str);

    if (print_screen_p && (print_screen_d >= 0)) {
        char nl = '\n';
        // TODO this should be uncached memory
        write(print_screen_d, str, strlen(str) );
        write(print_screen_d, &nl, 1);
    }
}

void script_end

(

)

Definiert in Zeile 230 der Datei script.c.

{
    // Tell other code that script has ended
    camera_info.state.state_kbd_script_run = SCRIPT_STATE_INACTIVE;
    camera_info.state.osd_title_line = 1 ;

    // reset the script terminate key
    script_terminate_key = KEY_SHOOT_FULL ;

    script_print_screen_end();
    console_set_autoredraw(1);          // Force console display on in case script turned it off

    // Restore old handler - prevent calling MD draw after module unloaded
    if (old_gui_handler)
    {
        extern gui_handler defaultGuiHandler; 
        // if script switched in or out of alt, try to preserve
        // TODO is there ever a situation where it should be something other than default or alt?
        if(old_gui_handler == &altGuiHandler && camera_info.state.gui_mode_none) {
            gui_set_mode(&defaultGuiHandler);
        } else if(old_gui_handler == &defaultGuiHandler && camera_info.state.gui_mode_alt) {
            gui_set_mode(&altGuiHandler);
        } else {
            gui_set_mode(old_gui_handler);
        }
        old_gui_handler = 0;
    }

    // Reset script language module
    libscriptapi->script_reset();

    // Kill off the action_stack for the script, since we've just reset the script
    // language and unloaded the MD module, we don't need to let the stack empty
    // itself.
    action_stack_kill(running_script_stack_name);
    running_script_stack_name = -1;

    libshothisto->shot_histogram_set(0);
    kbd_key_release_all();

    conf_setAutosave(1);    // Turn on autosave of config file in conf_setValue in case script turned it off
    conf_update_prevent_shutdown();
}

void script_get_alt_text

(

char *

buf)

Definiert in Zeile 148 der Datei script.c.

{
    if ((script_terminate_key != KEY_SHOOT_FULL) && camera_info.state.state_kbd_script_run)
    {
        sprintf(buf,"<EXIT=%s>",script_terminate_key_name);
    }
    else
    {
        strcpy(buf,"<ALT>");
    }
}

int script_is_running

(

)

Definiert in Zeile 135 der Datei script.c.

{
    return !action_stack_is_finished(running_script_stack_name);
}

static void script_print_screen_end ( )

static

Definiert in Zeile 51 der Datei script.c.

{
    if (print_screen_d >= 0) {
        close(print_screen_d);
        print_screen_d = -1;
        print_screen_p = 0;
    }
}

static void script_print_screen_init ( )

static

Definiert in Zeile 42 der Datei script.c.

{
    print_screen_p = 0;
    if (print_screen_d >= 0) {
        close(print_screen_d);
        print_screen_d = -1;
    }
}

void script_print_screen_statement

(

int

val)

Definiert in Zeile 60 der Datei script.c.

{
  // Negative values for 'val' parameter will append to log file,
  // positive values will truncate the log file
  int flag_trunc = O_TRUNC;

  print_screen_p = val;
  if (val) {
    if (print_screen_d>=0) close(print_screen_d);
    if (val<0) {
       flag_trunc = 0;
       val = -val;
    }
    while (val > 9999) val -= 10000;
    sprintf(print_screen_file, "A/CHDK/LOGS/LOG_%04d.TXT", val);
    print_screen_d = open(print_screen_file, O_WRONLY|O_CREAT|flag_trunc, 0777);
    if (print_screen_d>=0) lseek(print_screen_d,0,SEEK_END);
  }
  else script_print_screen_end() ;
}

void script_set_terminate_key	(	int	key,
		const char *	keyname
	)

Definiert in Zeile 141 der Datei script.c.

{
    script_terminate_key = key;
    strncpy(script_terminate_key_name,keyname,sizeof(script_terminate_key_name));
    script_terminate_key_name[sizeof(script_terminate_key_name)-1] = 0;
}

long script_stack_start

(

)

Definiert in Zeile 126 der Datei script.c.

{
    script_terminate_request = 0; // ensure any previous terminate request is cleared

    camera_info.state.state_kbd_script_run = SCRIPT_STATE_RAN;
    running_script_stack_name = action_stack_create(&action_stack_AS_SCRIPT_RUN);
    return running_script_stack_name;
}

long script_start_gui

(

int

autostart)

Definiert in Zeile 274 der Datei script.c.

{
    if (conf.script_file[0] == 0) return 0;

    libshothisto->shot_histogram_set(0);
    camera_info.state.auto_started = autostart;

    // Kill high speed USB timer if running
    stop_usb_HPtimer();

    // Keyboard init
    camera_info.state.kbd_last_clicked = 0;
    camera_info.state.kbd_last_checked_time = get_tick_count();
    kbd_key_release_all();

    // Close old console, will be re-opened when first line added
    console_close();
    script_print_screen_init();

    save_params_values(0);

    script_console_add_line((autostart)?LANG_CONSOLE_TEXT_AUTOSTARTED:LANG_CONSOLE_TEXT_STARTED);

    module_set_script_lang(conf.script_file);
    if ( !libscriptapi->script_start_file(conf.script_file) )
    {
        return -1;
    }

    sc_param *p = script_params;
    while (p)
    {
        if (p->name != 0)
        {
            libscriptapi->set_variable(p->name, p->val, (p->range == 1), (p->data_type == DTYPE_TABLE), p->option_count, p->options);
        }
        p = p->next;
    }

    conf_update_prevent_shutdown();

    old_gui_handler = gui_set_mode(&scriptGuiHandler);

    return script_stack_start();
}

void script_wait_terminate

(

void

)

Definiert in Zeile 217 der Datei script.c.

{
    if(camera_info.state.state_kbd_script_run == SCRIPT_STATE_INACTIVE) {
        return;
    }
    script_terminate_request = 1;
    // TODO timeout?
    while(camera_info.state.state_kbd_script_run != SCRIPT_STATE_INACTIVE) {
        msleep(10);
    }
}

Variablen-Dokumentation

gui_handler* old_gui_handler = 0

static

Definiert in Zeile 212 der Datei script.c.

int print_screen_d = -1

static

Definiert in Zeile 39 der Datei script.c.

char print_screen_file[25]

Definiert in Zeile 40 der Datei script.c.

int print_screen_p

static

Definiert in Zeile 38 der Datei script.c.

AS_ID running_script_stack_name = 0

static

Definiert in Zeile 21 der Datei script.c.

int script_terminate_key = KEY_SHOOT_FULL

static

Definiert in Zeile 25 der Datei script.c.

char script_terminate_key_name[20]

static

Definiert in Zeile 26 der Datei script.c.

int script_terminate_request = 0

static

Definiert in Zeile 28 der Datei script.c.

gui_handler scriptGuiHandler = { GUI_MODE_SCRIPT, gui_script_draw, gui_script_kbd_process, 0, 0, 0 }

Definiert in Zeile 210 der Datei script.c.