root/core/modules.c

DEFINITIONS

1. dummy_void
2. dummy_int
3. module_load_rawop
4. default_raw_merge_start
5. default_raw_subtract
6. module_restore_edge
7. module_save_edge
8. module_edgeovr_load
9. default_edge_overlay
10. default_load_edge_overlay
11. default_md_init_motion_detector
12. script_lang_id
13. module_set_script_lang
14. default_script_start
15. default_script_start_file
16. default_gui_osd_draw_zebra
17. default_histogram_process
18. default_gui_osd_draw_histo
19. module_curves_load
20. default_curve_init_mode
21. default_curve_set_mode
22. default_curve_set_file
23. default_gui_grid_draw_osd
24. default_grid_lines_load
25. default_show_palette
26. default_show_popup
27. default_file_select
28. default_create_badpixel_bin
29. default_capture_data_for_exif
30. default_load_bad_pixels_list_b
31. default_convert_dng_to_chdk_raw
32. default_load_dng_to_rawbuffer
33. default_textbox_init
34. default_hexbox_init
35. default_read_file
36. default_shot_histogram_set
37. default_shot_histogram_get_range

   1 /*
   2  *   CHDK-FLAT Module System.  
   3  *
   4  *   (c)2011 Sergey Taranenko aka tsvstar
   5  *
   6  *   Specific "shortcuts", dynamic libraries binding
   7  */
   9 #include "camera_info.h"
  10 #include "console.h"
  11 #include "conf.h"
  12 #include "modules.h"
  13 #include "module_load.h"
  14 #include "shooting.h"
  15 #include "ctype.h"
  17 //------------------------------------------------
  18 // Notes on the module auto-load system
  19 //
  20 // Module functions are called through a pointer to a module interface structure.
  21 // For example, the Raw Merge module interface is defined as:
  22 //        typedef struct
  23 //        {
  24 //            base_interface_t    base;
  25 //
  26 //            int (*raw_merge_start)(int action);
  27 //            int (*raw_merge_add_file)(const char* filename);
  28 //            void (*raw_merge_end)(void);
  29 //            int (*raw_subtract)(const char *fromName, const char *fromDir, const char *subName, const char *subDir);
  30 //        } librawop_sym;
  31 //
  32 // Each of the functions can be called through the global 'librawop' pointer.
  33 // For example:
  34 //      librawop->raw_merge_start(...);
  35 //
  36 // However the functions can only be called if the pointer actually points to something valid
  37 //
  38 // Prior to the auto-load system, the core code had to do something like this:
  39 //      if (librawop == 0)
  40 //      {
  41 //          librawop = module_load("_rawop.flt");
  42 //          ... probably do some error checking here as well
  43 //      }
  44 //      librawop->raw_merge_start(...);
  45 //      ... other Raw Merge stuff
  46 //      module_unload(librawop);
  47 //      librawop = 0;
  48 //
  49 // With the module auto-load system the core code can just call:
  50 //      librawop->raw_merge_start(...);
  51 // and everything else is take care of automatically.
  52 //
  53 // The system works by initialising every global module pointer to a dummy instance of the
  54 // module interface. The dummy interface must implement the same set of functions; but the
  55 // functions themselves don't have to do anything in all cases.
  56 //
  57 // The dummy interface for Raw Merge is:
  58 //        librawop_sym default_librawop =
  59 //        {
  60 //            { 0,0,0,0,0 },
  61 //            default_raw_merge_start,
  62 //            dummy_int,                  //raw_merge_add_file
  63 //            dummy_void,                 //raw_merge_end,
  64 //            default_raw_subtract
  65 //        };
  66 //
  67 // Only the raw_merge_start and raw_subtract functions do anything interesting, raw_merge_add_file
  68 // and raw_merge_end do nothing if the module is not loaded.
  69 //
  70 // The implementation of default_raw_merge_start, and default_raw_subtract (see code below)
  71 // try to load the actual module, if this is successful, then they call the equivalent module function
  72 //
  73 // Once the module is loaded into memory, the global module pointer is updated to point to the
  74 // module code. Subsequent calls to the module functions call the real module code, not the dummy
  75 // interface.
  76 //
  77 // When the module is unloaded, the global pointer is reset back to the dummy interface so future
  78 // calls will reload the module.
  79 //
  80 // Load / unload is managed with the module_handler_t structure. This contains pointers to the global
  81 // module pointer, the dummy interface, version and module name.
  82 //------------------------------------------------
  84 //------------------------------------------------
  85 // Dummy functions for default module libraries
  86 // Used when function does not need to do anything
  87 // unless module is loaded
  89 static void             dummy_void()    {}
  90 static int              dummy_int()     { return 0; }
  91 // static char*            dummy_pchar()   { return (char*)0; }
  92 // static unsigned char*   dummy_puchar()  { return (unsigned char*)0; }
  94 /************* DYNAMIC LIBRARY RAWOPERATION ******/
  96 // Forward reference
  97 extern librawop_sym default_librawop;
module_handler_t h_rawop =
 100 {
 101     (base_interface_t**)&librawop,
 102     &default_librawop.base,
RAW_MERGE_VERSION,
 104     "_rawop.flt"
 105 };
 107 static int module_load_rawop()
 108 {
 109     return module_load(&h_rawop);
 110 }
 112 // Default (unloaded) function(s)
 113 static int default_raw_merge_start(int action)
 114 {
 115     // If load succeeded call module version of function
 116     if (module_load_rawop())
 117         return librawop->raw_merge_start(action);
 119     // Failure
 120     return 0;
 121 }
 122 static int default_raw_subtract(const char *fromName, const char *fromDir, const char *subName, const char *subDir)
 123 {
 124     // If load succeeded call module version of function
 125     if (module_load_rawop())
 126         return librawop->raw_subtract(fromName, fromDir, subName, subDir);
 128     // Failure
 129     return 0;
 130 }
 132 // Default library - module unloaded
librawop_sym default_librawop =
 134 {
 135     { 0,0,0,0,0 },
default_raw_merge_start,
dummy_int,                  //raw_merge_add_file
dummy_void,                 //raw_merge_end,
default_raw_subtract
 140 };
 142 // Library pointer
librawop_sym* librawop = &default_librawop;
 146 /************* DYNAMIC LIBRARY EDGE OVERLAY ******/
 148 // Storage and interface for edge overlay 'image' buffer.
 149 // This is so the previous overlay can survive if the module gets unloaded
 150 static void* saved_edgebuf = 0;
 151 static int saved_edgestate = 0;
 153 int module_restore_edge(void **buf) { *buf = saved_edgebuf; return saved_edgestate; }
 154 void module_save_edge(void* buf, int state)      { saved_edgebuf = buf; saved_edgestate = state; }
 156 #define MODULE_NAME_EDGEOVR "edgeovr.flt"
 158 // Forward reference
 159 extern libedgeovr_sym default_libedgeovr;
module_handler_t h_edgeovr =
 162 {
 163     (base_interface_t**)&libedgeovr,
 164     &default_libedgeovr.base,
EDGEOVERLAY_VERSION,
MODULE_NAME_EDGEOVR
 167 };
 169 // Return: 0-fail, 1-ok
 170 static int module_edgeovr_load()
 171 {
 172     // This flag is because edgeovr called each tick
 173     //   If module loading failed, then do not try to load it until reboot
 174     //    (otherwise we will try to load module each tick)
 175     static int flag_load_fail = 0;
 177     if ( flag_load_fail==0 )
 178         if (!module_load(&h_edgeovr))
flag_load_fail = 1;
 181     return flag_load_fail == 0;
 182 }
 184 // Default (unloaded) function(s)
 185 static void default_edge_overlay()
 186 {
 187     // If load succeeded call module version of function
 188     if (module_edgeovr_load())
libedgeovr->edge_overlay();
 190 }
 191 static void default_load_edge_overlay(const char* fn)
 192 {
 193     // If load succeeded call module version of function
 194     if (module_edgeovr_load())
libedgeovr->load_edge_overlay(fn);
 196 }
 198 // Default library - module unloaded
libedgeovr_sym default_libedgeovr =
 200 {
 201     { 0,0,0,0,0 },
default_edge_overlay,
default_load_edge_overlay,
dummy_void,                 //save_edge_overlay
 205 };
 207 // Library pointer
libedgeovr_sym* libedgeovr = &default_libedgeovr;
 210 /************* DYNAMIC LIBRARY MOTION DETECT ******/
 212 #define MODULE_NAME_MDETECT "mdetect.flt"
 214 // Forward reference
 215 extern libmotiondetect_sym default_libmotiondetect;
module_handler_t h_motiondetect =
 218 {
 219     (base_interface_t**)&libmotiondetect,
 220     &default_libmotiondetect.base,
MOTION_DETECTOR_VERSION,
MODULE_NAME_MDETECT
 223 };
 225 // Default (unloaded) function(s)
 226 static int default_md_init_motion_detector(
 227  int columns, int rows, int pixel_measure_mode, int detection_timeout, int measure_interval, int threshold, int draw_grid, 
 228  int clipping_region_mode, int clipping_region_column1, int clipping_region_row1, int clipping_region_column2, int clipping_region_row2,
 229  int parameters, int pixels_step, int msecs_before_trigger)
 230 {
 231     // If load succeeded call module version of function
 232     if (module_load(&h_motiondetect))
 233         return libmotiondetect->md_init_motion_detector(
columns, rows, pixel_measure_mode, detection_timeout, measure_interval, threshold, draw_grid, 
clipping_region_mode, clipping_region_column1, clipping_region_row1, clipping_region_column2, clipping_region_row2,
parameters, pixels_step, msecs_before_trigger);
 238     // Failure
 239     return 0;
 240 }
 242 // Default library - module unloaded
libmotiondetect_sym default_libmotiondetect =
 244 {
 245     { 0,0,0,0,0 },
dummy_void,                         //md_close_motion_detector
default_md_init_motion_detector,
dummy_int,                          //md_get_cell_diff
dummy_void,                         //md_draw_grid
dummy_int                           //md_get_cell_val
 251 };
 253 // Library pointer
libmotiondetect_sym* libmotiondetect = &default_libmotiondetect;
 256 /************* DYNAMIC LIBRARY Script language ******/
 258 #define MODULE_NAME_UNK     "unknown"
 259 #define MODULE_NAME_LUA     "lua.flt"
 260 #define MODULE_NAME_UBASIC  "ubasic.flt"
 262 // Forward reference
 263 extern libscriptapi_sym default_libscriptapi;
module_handler_t h_script =
 266 {
 267     (base_interface_t**)&libscriptapi,
 268     &default_libscriptapi.base,
SCRIPT_API_VERSION,
MODULE_NAME_UNK
 271 };
 273 // Which script language is being used
 274 #define SCRIPT_LANG_NONE    0
 275 #define SCRIPT_LANG_UBASIC  1
 276 #define SCRIPT_LANG_LUA     2
 278 static int current_lang_id = SCRIPT_LANG_NONE;
 280 static int script_lang_id(const char* script_file)
 281 {
 282     if ((script_file == 0) || (script_file[0] == 0))
 283         return SCRIPT_LANG_LUA;  // Default script is Lua
 285     char *ext = strrchr(script_file,'.');
 287     if (ext && (strlen(ext) == 4) && (toupper(ext[1]) == 'L') && (toupper(ext[2]) == 'U') && (toupper(ext[3]) == 'A'))
 288         return SCRIPT_LANG_LUA;
 290     return SCRIPT_LANG_UBASIC;
 291 }
 293 void module_set_script_lang(const char* script_file)
 294 {
 295     char* lang_names[] = { MODULE_NAME_UNK, MODULE_NAME_UBASIC, MODULE_NAME_LUA };
 297     int lang_id = script_lang_id(script_file);
 299     if (lang_id != current_lang_id)
 300     {
module_unload(h_script.name);
current_lang_id = lang_id;
h_script.name = lang_names[lang_id];
 304     }
 305 }
 307 // Default (unloaded) function(s)
 308 static int default_script_start(char const* script, int is_ptp)
 309 {
 310     // If load succeeded call module version of function
 311     if (module_load(&h_script))
 312         return libscriptapi->script_start(script, is_ptp);
 314     // Failure
 315     return 0;
 316 }
 317 static int default_script_start_file(char const* filename)
 318 {
 319     // If load succeeded call module version of function
 320     if (module_load(&h_script))
 321         return libscriptapi->script_start_file(filename);
 323     // Failure
 324     return 0;
 325 }
 327 // Default library - module unloaded
libscriptapi_sym default_libscriptapi =
 329 {
 330     { 0,0,0,0,0 },
default_script_start,
default_script_start_file,
dummy_int,              //script_run
dummy_void,             //script_reset
dummy_void,             //set_variable
dummy_void,             //set_as_ret
dummy_int,               //run_restore
dummy_void,             //shoot_hook
 339 };
 341 // Library pointer
libscriptapi_sym* libscriptapi = &default_libscriptapi;
 344 /************* DYNAMIC LIBRARY ZEBRA ******/
 346 #define MODULE_NAME_ZEBRA "zebra.flt"
 348 // Forward reference
 349 extern libzebra_sym default_libzebra;
module_handler_t h_zebra =
 352 {
 353     (base_interface_t**)&libzebra,
 354     &default_libzebra.base,
ZEBRA_VERSION,
MODULE_NAME_ZEBRA
 357 };
 359 // Default (unloaded) function(s)
 360 static int default_gui_osd_draw_zebra(int show)
 361 {
 362     // If load succeeded call module version of function
 363     if (module_load(&h_zebra))
 364         return libzebra->gui_osd_draw_zebra(show);
 366     // Failure
 367     return 0;
 368 }
 370 // Default library - module unloaded
libzebra_sym default_libzebra =
 372 {
 373     { 0,0,0,0,0 },
default_gui_osd_draw_zebra
 375 };
 377 // Library pointer
libzebra_sym* libzebra = &default_libzebra;
 380 /************* DYNAMIC LIBRARY HISTOGRAM ******/
 382 #define MODULE_NAME_HISTO "histo.flt"
 384 // Forward reference
 385 extern libhisto_sym default_libhisto;
module_handler_t h_histo =
 388 {
 389     (base_interface_t**)&libhisto,
 390     &default_libhisto.base,
HISTO_VERSION,
MODULE_NAME_HISTO
 393 };
 395 // Default (unloaded) function(s)
 396 static void default_histogram_process()
 397 {
 398     // If load succeeded call module version of function
 399     if (module_load(&h_histo))
libhisto->histogram_process();
 401 }
 403 // Default (unloaded) function(s)
 404 static void default_gui_osd_draw_histo(int is_osd_edit)
 405 {
 406     if (is_osd_edit ||
 407         ((camera_info.state.mode_play || !camera_info.state.mode_video) &&
 408          (
 409           ((conf.show_histo==SHOW_HISTO_HALF) && camera_info.state.is_shutter_half_press) ||
 410           ((conf.show_histo==SHOW_HISTO_REC) && camera_info.state.mode_rec && (recreview_hold==0)) ||
 411           ((conf.show_histo==SHOW_HISTO_ALWAYS) && (recreview_hold==0))
 412          )
 413         )
 414        )
 415     {
 416         // If load succeeded call module version of function
 417         if (module_load(&h_histo))
libhisto->gui_osd_draw_histo(is_osd_edit);
 419     }
 420 }
 422 // Default library - module unloaded
libhisto_sym default_libhisto =
 424 {
 425     { 0,0,0,0,0 },
default_histogram_process,
default_gui_osd_draw_histo
 428 };
 430 // Library pointer
libhisto_sym* libhisto = &default_libhisto;
 433 /************* DYNAMIC LIBRARY CURVES ******/
 435 #define MODULE_NAME_CURVES "curves.flt"
 437 // Forward reference
 438 extern libcurves_sym default_libcurves;
module_handler_t h_curves =
 441 {
 442     (base_interface_t**)&libcurves,
 443     &default_libcurves.base,
CURVES_VERSION,
MODULE_NAME_CURVES
 446 };
 448 // Return: 0-fail, addr-ok
 449 static int module_curves_load()
 450 {
 451     if (camera_sensor.bits_per_pixel == 10)
 452         return module_load(&h_curves);
 453     return 0;
 454 }
 456 // Default (unloaded) function(s)
 457 static void default_curve_init_mode()
 458 {
 459     // If load succeeded call module version of function
 460     if (module_curves_load())
libcurves->curve_init_mode();
 462 }
 463 static void default_curve_set_mode()
 464 {
 465     // If load succeeded call module version of function
 466     if (module_curves_load())
libcurves->curve_set_mode();
 468 }
 469 static void default_curve_set_file()
 470 {
 471     // If load succeeded call module version of function
 472     if (module_curves_load())
libcurves->curve_set_file();
 474 }
 476 // Default library - module unloaded
libcurves_sym default_libcurves =
 478 {
 479     { 0,0,0,0,0 },
default_curve_init_mode,
dummy_void,                 //curve_apply
default_curve_set_mode,
default_curve_set_file
 484 };
 486 // Library pointer
libcurves_sym* libcurves = &default_libcurves;
 489 /************* DYNAMIC LIBRARY GRIDS ******/
 491 #define MODULE_NAME_GRIDS "grids.flt"
 493 // Forward reference
 494 extern libgrids_sym default_libgrids;
module_handler_t h_grids =
 497 {
 498     (base_interface_t**)&libgrids,
 499     &default_libgrids.base,
GUI_GRID_VERSION,
MODULE_NAME_GRIDS
 502 };
 504 // Default (unloaded) function(s)
 505 static void default_gui_grid_draw_osd(int force)
 506 {
 507     // If load succeeded call module version of function
 508     if (conf.show_grid_lines)
 509         if (module_load(&h_grids))
libgrids->gui_grid_draw_osd(force);
 511 }
 512 static void default_grid_lines_load(const char *fn)
 513 {
 514     // If load succeeded call module version of function
 515     if (module_load(&h_grids))
libgrids->grid_lines_load(fn);
 517 }
 519 // Default library - module unloaded
libgrids_sym default_libgrids =
 521 {
 522     { 0,0,0,0,0 },
default_gui_grid_draw_osd,
default_grid_lines_load
 525 };
 527 // Library pointer
libgrids_sym* libgrids = &default_libgrids;
 531 /************* MODULE PALETTE ******/
 533 #define MODULE_NAME_PALETTE "palette.flt"
 535 // Forward reference
 536 extern libpalette_sym default_libpalette;
module_handler_t h_palette =
 539 {
 540     (base_interface_t**)&libpalette,
 541     &default_libpalette.base,
GUI_PALETTE_VERSION,
MODULE_NAME_PALETTE
 544 };
 546 // Default (unloaded) function
 547 static void default_show_palette(int mode, chdkColor st_color, void (*on_select)(chdkColor clr))
 548 {
 549     // If load succeeded call module version of function
 550     if (module_load(&h_palette))
libpalette->show_palette(mode, st_color, on_select);
 552 }
 554 // Default library - module unloaded
libpalette_sym default_libpalette =
 556 {
 557     { 0,0,0,0,0 },
default_show_palette
 559 };
 561 // Library pointer
libpalette_sym* libpalette = &default_libpalette;
 564 /************* MODULE MPOPUP ******/
 566 #define MODULE_NAME_MPOPUP "mpopup.flt"
 568 // Forward reference
 569 extern libmpopup_sym default_libmpopup;
module_handler_t h_mpopup =
 572 {
 573     (base_interface_t**)&libmpopup,
 574     &default_libmpopup.base,
GUI_MPOPUP_VERSION,
MODULE_NAME_MPOPUP
 577 };
 579 // Default (unloaded) function
 580 static void default_show_popup(struct mpopup_item* popup_actions, const unsigned int flags, void (*on_select)(unsigned int actn))
 581 {
 582     // If load succeeded call module version of function
 583     if (module_load(&h_mpopup))
libmpopup->show_popup(popup_actions, flags, on_select);
 585 }
 587 // Default library - module unloaded
libmpopup_sym default_libmpopup =
 589 {
 590     { 0,0,0,0,0 },
default_show_popup
 592 };
 594 // Library pointer
libmpopup_sym* libmpopup = &default_libmpopup;
 597 /************* MODULE FSELECT ******/
 599 #define MODULE_NAME_FSELECT "fselect.flt"
 601 // Forward reference
 602 extern libfselect_sym default_libfselect;
module_handler_t h_fselect =
 605 {
 606     (base_interface_t**)&libfselect,
 607     &default_libfselect.base,
GUI_FSELECT_VERSION,
MODULE_NAME_FSELECT
 610 };
 612 // Default (unloaded) function
 613 static void default_file_select(int title, const char* prev_dir, const char* default_dir, void (*on_select)(const char *fn))
 614 {
 615     // If load succeeded call module version of function
 616     if (module_load(&h_fselect))
libfselect->file_select(title, prev_dir, default_dir, on_select);
 618 }
 620 // Default library - module unloaded
libfselect_sym default_libfselect =
 622 {
 623     { 0,0,0,0,0 },
default_file_select
 625 };
 627 // Library pointer
libfselect_sym* libfselect = &default_libfselect;
 630 /************* MODULE DNG ******/
 632 #define MODULE_NAME_DNG "_dng.flt"
 634 // Forward reference
 635 extern libdng_sym default_libdng;
module_handler_t h_dng =
 638 {
 639     (base_interface_t**)&libdng,
 640     &default_libdng.base,
DNG_VERSION,
MODULE_NAME_DNG
 643 };
 645 // Default (unloaded) function
 646 static void default_create_badpixel_bin()
 647 {
 648     // If load succeeded call module version of function
 649     if (module_load(&h_dng))
libdng->create_badpixel_bin();
 651 }
 652 static void default_capture_data_for_exif()
 653 {
 654     // If load succeeded call module version of function
 655     if (module_load(&h_dng))
libdng->capture_data_for_exif();
 657 }
 658 static void default_load_bad_pixels_list_b(char* filename)
 659 {
 660     // If load succeeded call module version of function
 661     if (module_load(&h_dng))
libdng->load_bad_pixels_list_b(filename);
 663 }
 664 static int default_convert_dng_to_chdk_raw(char* fn)
 665 {
 666     // If load succeeded call module version of function
 667     if (module_load(&h_dng))
 668         return libdng->convert_dng_to_chdk_raw(fn);
 670     // Failure
 671     return 0;
 672 }
 673 static void default_load_dng_to_rawbuffer(char *fn, char *rawadr)
 674 {
 675     // If load succeeded call module version of function
 676     if (module_load(&h_dng))
libdng->load_dng_to_rawbuffer(fn, rawadr);
 678 }
 680 // Default library - module unloaded
libdng_sym default_libdng =
 682 {
 683     { 0,0,0,0,0 },
default_create_badpixel_bin,
dummy_int,                          //raw_init_badpixel_bin
default_capture_data_for_exif,
default_load_bad_pixels_list_b,
dummy_int,                          //badpixel_list_loaded_b
default_convert_dng_to_chdk_raw,
dummy_int,                          //write_dng
default_load_dng_to_rawbuffer,
dummy_void,                         //create_dng_header_for_ptp
dummy_void                          //free_dng_header_for_ptp
 694 };
 696 // Library pointer
libdng_sym* libdng = &default_libdng;
 699 /************* MODULE TBOX ******/
 701 #define MODULE_NAME_TBOX "_tbox.flt"
 703 // Forward reference
 704 extern libtextbox_sym default_libtextbox;
module_handler_t h_textbox =
 707 {
 708     (base_interface_t**)&libtextbox,
 709     &default_libtextbox.base,
GUI_TBOX_VERSION,
MODULE_NAME_TBOX
 712 };
 714 // Default (unloaded) function
 715 static int default_textbox_init(int title, int msg, const char* defaultstr, unsigned int maxsize, void (*on_select)(const char* newstr), char *input_buffer)
 716 {
 717     // If load succeeded call module version of function
 718     if (module_load(&h_textbox))
 719         return libtextbox->textbox_init(title,msg,defaultstr,maxsize,on_select,input_buffer);
 721     // Failure
 722     return 0;
 723 }
 725 // Default library - module unloaded
libtextbox_sym default_libtextbox =
 727 {
 728     { 0,0,0,0,0 },
default_textbox_init,
 730 };
 732 // Library pointer
libtextbox_sym* libtextbox = &default_libtextbox;
 735 /************* MODULE HEXBOX ******/
 737 #define MODULE_NAME_HEXBOX "_hexbox.flt"
 739 // Forward reference
 740 extern libhexbox_sym default_libhexbox;
module_handler_t h_hexbox =
 743 {
 744     (base_interface_t**)&libhexbox,
 745     &default_libhexbox.base,
GUI_HEXBOX_VERSION,
MODULE_NAME_HEXBOX
 748 };
 750 // Default (unloaded) function
 751 static int default_hexbox_init(int *num, char *title, int flags)
 752 {
 753     // If load succeeded call module version of function
 754     if (module_load(&h_hexbox))
 755         return libhexbox->hexbox_init(num, title, flags);
 757     // Failure
 758     return 0;
 759 }
 761 // Default library - module unloaded
libhexbox_sym default_libhexbox =
 763 {
 764     { 0,0,0,0,0 },
default_hexbox_init,
 766 };
 768 // Library pointer
libhexbox_sym* libhexbox = &default_libhexbox;
 771 /************* MODULE TXTREAD ******/
 773 #define MODULE_NAME_TXTREAD "txtread.flt"
 775 // Forward reference
 776 extern libtxtread_sym default_libtxtread;
module_handler_t h_txtread =
 779 {
 780     (base_interface_t**)&libtxtread,
 781     &default_libtxtread.base,
GUI_READ_VERSION,
MODULE_NAME_TXTREAD
 784 };
 786 // Default (unloaded) function
 787 static int default_read_file(const char *fn)
 788 {
 789     // If load succeeded call module version of function
 790     if (module_load(&h_txtread))
 791         return libtxtread->read_file(fn);
 793     // Failure
 794     return 0;
 795 }
 797 // Default library - module unloaded
libtxtread_sym default_libtxtread =
 799 {
 800     { 0,0,0,0,0 },
default_read_file,
 802 };
 804 // Library pointer
libtxtread_sym* libtxtread = &default_libtxtread;
 807 /************* MODULE Shot Histogram ******/
 809 #define MODULE_NAME_SHOTHIST "shothist.flt"
 811 // Forward reference
 812 extern libshothisto_sym default_libshothisto;
module_handler_t h_shothisto =
 815 {
 816     (base_interface_t**)&libshothisto,
 817     &default_libshothisto.base,
SHOT_HISTO_VERSION,
MODULE_NAME_SHOTHIST
 820 };
 822 static int default_shot_histogram_set(int enable)
 823 {
 824     // If enabling shot histogram, then load module, otherwise nothing to do
 825     if (enable)
 826         if (module_load(&h_shothisto))
 827             return libshothisto->shot_histogram_set(enable);
 828     return 1;
 829 }
 830 static int default_shot_histogram_get_range()
 831 {
 832     return -1;  // Module not loaded
 833 }
 835 // Default library - module unloaded
libshothisto_sym default_libshothisto=
 837 {
 838     { 0,0,0,0,0 },
default_shot_histogram_set,
default_shot_histogram_get_range,
dummy_void,                         //build_shot_histogram,
dummy_void,                         //write_to_file
 843 };
 845 // Library pointer
libshothisto_sym* libshothisto = &default_libshothisto;