void pragma_config_load::run(const data::command::iterator&,
const data::command::iterator&,
const data::command::iterator& args_begin_,
const data::command::iterator& args_end_,
iface::displayer& displayer_) const
{
const data::shell_config_name name = data::shell_config_name(
tokens_to_string(args_begin_, args_end_).value());
const auto& configs = _shell.get_config().shell_configs();
const auto cfg = std::find_if(
configs.begin(), configs.end(),
[&name](const data::shell_config& cfg_) { return cfg_.name == name; });
if (cfg == configs.end())
{
throw exception("Config " + name + " not found.");
}
else
{
const auto old_config = _shell.get_config().active_shell_config().name;
_shell.get_config().activate(name);
try
{
_shell.rebuild_environment();
displayer_.show_comment(data::text("Switched to config " + name));
}
catch (const std::exception& e)
{
displayer_.show_error("Error loading config " + name + ": " + e.what());
restore_config(old_config, _shell);
}
catch (...)
{
displayer_.show_error("Error loading config " + name +
": unknown exception");
restore_config(old_config, _shell);
}
}
}
void btn_restore_config_clicked(GtkButton *button, gpointer user_data)
{
GtkWidget *dialog, *err_dialog;
char *file_name=NULL;
int ret;
dialog = gtk_file_chooser_dialog_new( "Restore from file",
GTK_WINDOW(GET_WIDGET(WIN_CONFIG)),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), "/home");
//gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "btnx_conf_backup.tar.gz");
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
file_name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
ret = restore_config(file_name, 0);
switch (ret)
{
case ERROR_RESTORE_EXTRACT_VERSION:
SHOW_ERROR_DIALOG(err_dialog, GET_WIDGET(WIN_CONFIG),
TEXT_RESTORE_ERROR,
_("Possibly broken or invalid backup file."));
break;
case ERROR_RESTORE_VERSION_INCOMPATIBLE:
SHOW_ERROR_DIALOG(err_dialog, GET_WIDGET(WIN_CONFIG),
TEXT_RESTORE_ERROR,
_("The backup configuration is from an incompatible version of "
"btnx. Restore operation cancelled."));
break;
case ERROR_RESTORE_TAR_EXTRACT:
SHOW_ERROR_DIALOG(err_dialog, GET_WIDGET(WIN_CONFIG),
TEXT_RESTORE_ERROR,
_("Unspecified tar execution failure."));
break;
default:
config_clear_all();
config_manager_init();
udev_init();
settings_file_parse();
config_refresh_advanced_settings();
break;
}
}
if (file_name != NULL)
g_free(file_name);
gtk_widget_destroy(dialog);
}
bool AVRClose()
{
if (AVRfd != -1) /** Device wurde geoeffnet **/
restore_config();
if (close(AVRfd) == -1)
{
AVRfd = -1;
return 0;
}
else
{
AVRfd = -1;
return 1;
}
}
/* main function */
int main(int argc, char *argv[])
{
int ret = 0, d, index;
char shortoptions[] = "i:s:d:w:p:m:f:";
DBGENTER;
for (;;) {
d = getopt_long(argc, argv, shortoptions, (void *)NULL, &index);
if (-1 == d)
break;
switch (d) {
case 'f':
field = atoi(optarg);
break;
case 'i':
vpfe_input = atoi(optarg);
break;
case 'm':
input_std = atoi(optarg);
break;
case 's':
case 'S':
stress_test = atoi(optarg);
break;
case 'd':
case 'D':
display_out = atoi(optarg);
break;
case 'w':
case 'W':
save_frame = atoi(optarg);
break;
case 'p':
case 'P':
print_fn = atoi(optarg);
break;
default:
menu();
exit(1);
}
}
printf("input_std %d, vpfe_input %d\n", input_std, vpfe_input);
if(vpfe_input == 0 || vpfe_input == 1)
{
if(input_std == 0)
{
BUF_SIZE = 720*480*2;
}
else if(input_std == 1)
{
BUF_SIZE = 720*576*2;
}
}
else if(vpfe_input == 2)
{
if(input_std == 0)
{
BUF_SIZE = 640*480;
}
else if(input_std == 1)
{
BUF_SIZE = 736*480;
}
else if(input_std == 2)
{
BUF_SIZE = 736*576;
}
else if(input_std == 3)
{
BUF_SIZE = 1280*720;
}
else if(input_std == 4)
{
BUF_SIZE = 1920*1080;
}
else if(input_std == 5)
{
BUF_SIZE = 2048*1536;
}
} else if (vpfe_input == 3) {
if(input_std == 0)
{
BUF_SIZE = 1280*720*2;
}
else if(input_std == 1)
{
BUF_SIZE = 1920*1080*2;
}
}
if (save_frame) {
switch (vpfe_input) {
case 2:
if (input_std == 0)
file_fp = fopen(CAPTURE_FILE_VGA, "wb");
else if (input_std == 1)
file_fp = fopen(CAPTURE_FILE_480P, "wb");
else if (input_std == 2)
file_fp = fopen(CAPTURE_FILE_576P, "wb");
else if (input_std == 3)
file_fp = fopen(CAPTURE_FILE_720P, "wb");
else if (input_std == 4)
file_fp = fopen(CAPTURE_FILE_1080P, "wb");
else
file_fp = fopen(CAPTURE_FILE, "wb");
break;
case 3:
if (input_std == 0)
file_fp = fopen(CAPTURE_FILE_720P, "wb");
if (input_std == 1)
file_fp = fopen(CAPTURE_FILE_1080I, "wb");
break;
case 1:
default:
file_fp = fopen(CAPTURE_FILE, "wb");
}
if (file_fp == NULL) {
printf("Unable to open %s\n", CAPTURE_FILE);
exit(1);
}
}
if (display_out) {
if (open_all_windows() != 0) {
printf("Test fail\n");
exit(1);
}
}
if (allocate_user_buffers() < 0) {
printf("hi Test fail\n");
exit(1);
}
ret = vpbe_UE_1();
if (ret == SUCCESS)
capture_streamoff();
if (display_out) {
restore_config();
close_all_windows();
}
close(fdCapture);
DBGEXIT;
return ret;
}
int main(int argc, char *argv[])
#endif
{
/* C90 requires all vars to be declared at top of function */
CoiHandle entity;
CoiHandle node;
CoiHandle light;
CoiHandle rendersystem;
CoiHandle renderwindow;
CoiHandle viewport;
CoiHandle plane;
CoiHandle plane_entity;
CoiHandle plane_node;
CoiHandle terrain_group;
CoiHandle terrain_iterator;
CoiHandle import_data;
CoiHandle image;
float direction[3];
float colour[4];
#if defined(LLCOI_TEST_USE_OPENINPUT)
// Openinput
oi_event evt;
char openinput_window_params[100];
unsigned int windowHnd = 0;
#if defined(PLATFORM_LINUX)
Display *disp;
Window win;
unsigned int scrn;
#endif
#endif //LLCOI_TEST_USE_OPENINPUT
keep_going = 1;
long loop_x = 0;
long loop_y = 0;
// setup
create_root("plugins.cfg", "ogre.cfg", "ogre.log");
if (!(restore_config() || show_config_dialog()))
{
return 1;
}
setup_resources("resources.cfg");
renderwindow = root_initialise(1, "Ogre Renderwindow");
set_default_num_mipmaps(5);
initialise_all_resource_groups();
create_scene_manager("OctreeSceneManager", "The SceneManager");
myCamera = create_camera(get_scene_manager(), "mycam");
camera_set_position(myCamera, 1683, 50, 2116);
camera_lookat(myCamera, 1963, -50, 1660);
camera_set_near_clip_distance(myCamera, 1);
camera_set_far_clip_distance(myCamera, 50000);
viewport = add_viewport(myCamera);
viewport_set_background_colour(viewport, 0, 0, 0);
camera_set_aspect_ratio(myCamera, 800, 600);
// entities
plane = create_plane_from_normal(0, 1, 0, 0);
mesh_manager_create_plane("ground", "General", plane, 1500, 1500, 20, 20, 1, 1, 5, 5, 0, 0, 1);
plane_entity = create_entity(get_scene_manager(), "plane", "ground");
entity_set_material_name(plane_entity, "Dev/Red");
plane_node = create_child_scene_node(get_scene_manager(), "planenode");
scene_node_attach_entity(plane_node, plane_entity);
entity = create_entity(get_scene_manager(), "OgreHead", "ogrehead.mesh");
node = create_child_scene_node(get_scene_manager(), "headNode");
scene_node_attach_entity(node, entity);
scene_manager_set_ambient_light_rgb(get_scene_manager(), 0.5f, 0.5f, 0.5f);
light = create_light(get_scene_manager(), "mainLight");
light_set_position(light, 20, 80, 50);
// terrain
create_terrain_global_options();
terrain_group = create_terrain_group(get_scene_manager(), ALIGN_X_Z, 513, 12000.0f);
terrain_group_set_filename_convention(terrain_group, "BasicTutorial3Terrain", "dat");
terrain_group_set_origin(terrain_group, 0, 0, 0);
// terrain defaults
terrain_global_options_set_max_pixel_error(8);
terrain_global_options_set_composite_map_distance(3000);
terrain_global_options_set_light_map_direction_vector3(light_get_derived_direction(light));
terrain_global_options_set_composite_map_ambient_colour(scene_manager_get_ambient_light(get_scene_manager()));// sm
terrain_global_options_set_composite_map_diffuse_colour(light_get_diffuse_colour(light));// light
import_data = terrain_group_get_default_import_settings(terrain_group);
terrain_group_import_data_set_terrain_size(import_data, 513);
terrain_group_import_data_set_world_size(import_data, 12000.0f);
terrain_group_import_data_set_input_scale(import_data, 600);
terrain_group_import_data_set_min_batch_size(import_data, 33);
terrain_group_import_data_set_max_batch_size(import_data, 65);
terrain_group_import_data_resize_layers(import_data, 3);
terrain_group_import_data_set_layer(import_data, 0, 100, "nvidia/dirt_grayrocky_diffusespecular.dds", "nvidia/dirt_grayrocky_normalheight.dds");
terrain_group_import_data_set_layer(import_data, 1, 30, "nvidia/grass_green-01_diffusespecular.dds", "nvidia/grass_green-01_normalheight.dds");
terrain_group_import_data_set_layer(import_data, 2, 200, "nvidia/growth_weirdfungus-03_diffusespecular.dds", "nvidia/growth_weirdfungus-03_normalheight.dds");
// define terrains
for (loop_x; loop_x <= 0; ++loop_x)
{
for (loop_y; loop_y <= 0; ++loop_y)
{
if (resource_exists(terrain_group_get_resource_group(terrain_group), terrain_group_generate_filename(terrain_group, loop_x, loop_y)))
{
terrain_group_define_terrain(terrain_group, loop_x, loop_y);
}
else
{
image = create_image();
image_load(image, "terrain.png");
if (loop_x % 2 != 0)
{
image_flip_around_y(image);
}
if (loop_y % 2 != 0)
{
image_flip_around_x(image);
}
terrain_group_define_terrain_image(terrain_group, loop_x, loop_y, image);
image_delete(image);
image = NULL;
}
}
}
terrain_group_load_all_terrains(terrain_group, 1);
// blend maps
/*
terrain_iterator = terrain_group_get_terrain_iterator(terrain_group);
while(terrain_iterator_has_more_elements(terrain_iterator))
{
CoiHandle terrain = terrain_iterator_get_next(terrain_iterator);
int blend_map_size = terrain_get_layer_blend_map_size(terrain);
CoiHandle blend_map_0 = terrain_get_layer_blend_map(terrain, 1);
CoiHandle blend_map_1 = terrain_get_layer_blend_map(terrain, 2);
float min_height_0 = 70;
float fade_dist_0 = 40;
float min_height_1 = 70;
float fade_dist_1 = 15;
float* blend_1 = terrain_layer_blend_map_get_blend_pointer(blend_map_1);
for(unsigned int y = 0; y < blend_map_size; ++y)
{
for(unsigned int x = 0; x < blend_map_size; ++x)
{
float tx, ty;
terrain_layer_blend_map_convert_image_to_terrain_space(x, y, &tx, &ty);
float height = terrain_get_height_at_terrain_position(tx, ty);
float val = (height - min_height_0) / fade_dist_0;
val = math_clamp_f(val, 0.0f, 1.0f);
val = (height - min_height_1) / fade_dist_1;
val = math_clamp_f(val, 0.0f, 1.0f);
*blend_1++ = val;
}
}
terrain_layer_blend_map_dirty(blend_map_0);
terrain_layer_blend_map_dirty(blend_map_1);
terrain_layer_blend_map_update(blend_map_0);
terrain_layer_blend_map_update(blend_map_1);
}
*/
terrain_group_free_temporary_resources(terrain_group);
// listeners
add_frame_listener(frame_listener_test,EVENT_FRAME_RENDERING_QUEUED|EVENT_FRAME_STARTED);
add_window_listener(renderwindow, window_event_listener_test);
input_manager = create_input_system(render_window_get_hwnd(renderwindow));
input_listener = create_input_listener();
keyboard = create_keyboard_object(input_manager, 1);
mouse = create_mouse_object(input_manager, 1);
attach_keyboard_listener(keyboard, input_listener);
attach_mouse_listener(mouse, input_listener);
add_key_pressed_listener(input_listener, key_pressed_test);
while(keep_going)
{
keyboard_capture(keyboard);
mouse_capture(mouse);
// Pump window messages for nice behaviour
pump_messages();
// Render a frame
render_one_frame();
if (render_window_closed(renderwindow))
{
keep_going = 0;
}
}
#if defined(LLCOI_TEST_USE_OPENINPUT)
windowHnd = render_window_get_hwnd(renderwindow);
#if defined(PLATFORM_LINUX)
disp = XOpenDisplay( NULL );
scrn = DefaultScreen(disp);
sprintf(openinput_window_params, "c:%u s:%u w:%u", (unsigned int)disp, (unsigned int)scrn, windowHnd);
#else
sprintf(openinput_window_params, "c:%u s:%u w:%u", 0, 0, windowHnd);
#endif
oi_init(openinput_window_params, 0);
log_message("***************************");
log_message("*** All Systems online! ***");
log_message("***************************");
//render_loop();
while (keep_going)
{
// ask oi to wait for events
oi_events_poll(&evt);
switch(evt.type)
{
case OI_QUIT:
// Quit
keep_going = 0;
break;
case OI_KEYDOWN:
// Keyboard button down
//WTF?? Better way to check this, please..
if(evt.key.keysym.sym == OIK_ESC)
keep_going = 0;
break;
default:
break;
}
// Pump window messages for nice behaviour
pump_messages();
// Render a frame
render_one_frame();
if (render_window_closed())
{
keep_going = 0;
}
}
oi_close();
#endif //LLCOI_TEST_USE_OPENINPUT
remove_window_listener(renderwindow);
destroy_keyboard_object(input_manager, keyboard);
destroy_mouse_object(input_manager, mouse);
destroy_input_system(input_manager);
release_engine();
return 0;
}
int main(int argc, char **argv)
{
// init vars
have_xtest = False;
numConfigs = 0;
currConfig = 0;
gui_selectConfig = 0;
G15Version = 0;
config_fd = 0;
mled_state = G15_LED_M1;
mkey_state = 0;
recording = 0;
// this is for keeping track of when to redraw
gui_oldConfig = MAX_CONFIGS+1; // To make sure it will be redrawn at first
was_recording = 1;
#ifdef USE_XTEST
int xtest_major_version = 0;
int xtest_minor_version = 0;
#endif
struct sigaction new_action;
int dummy=0,i=0;
unsigned char user[256];
struct passwd *username;
char splashpath[1024];
unsigned int dump = 0;
unsigned int keysonly = 0;
FILE *config;
unsigned int convert = 0;
memset(configDir,0,sizeof(configDir));
strncpy(configDir,getenv("HOME"),1024);
strncat(configDir,"/.g15macro/",1024-strlen(configDir));
strncpy(configpath,getenv("HOME"),1024);
memset(user,0,256);
for(i=0;i<argc;i++){
if (!strncmp(argv[i], "-u",2) || !strncmp(argv[i], "--user",6)) {
if(argv[i+1]!=NULL){
strncpy((char*)user,argv[i+1],128);
i++;
}
}
if (!strncmp(argv[i], "-d",2) || !strncmp(argv[i], "--dump",6)) {
dump = 1;
}
if (!strncmp(argv[i], "-h",2) || !strncmp(argv[i], "--help",6)) {
helptext();
exit(0);
}
if (!strncmp(argv[i], "-k",2) || !strncmp(argv[i], "--keysonly",10)) {
keysonly = 1;
}
if (!strncmp(argv[i], "-g",2) || !strncmp(argv[i], "--debug",7)) {
printf("Debugging Enabled\n");
debug = 1;
}
if (!strncmp(argv[i], "-v",2) || !strncmp(argv[i], "--version",9)) {
printf("G15Macro version %s\n\n",PACKAGE_VERSION);
exit(0);
}
if (!strncmp(argv[i], "-2",2) || !strncmp(argv[i], "--g15version2",13))
{
G15Version = 1; // See declaration for info
}
}
if(strlen((char*)user)){
username = getpwnam((char*)user);
if (username==NULL) {
username = getpwuid(geteuid());
printf("BEWARE: running as effective uid %i\n",username->pw_uid);
}
else {
if(0==setuid(username->pw_uid)) {
setgid(username->pw_gid);
strncpy(configpath,username->pw_dir,1024);
strncpy(configDir,username->pw_dir,1024);
printf("running as user %s\n",username->pw_name);
}
else
printf("Unable to run as user \"%s\" - you dont have permissions for that.\nRunning as \"%s\"\n",username->pw_name,getenv("USER"));
}
printf("BEWARE: this program will run files WITHOUT dropping any kind of privilegies.\n");
}
canvas = (g15canvas *) malloc (sizeof (g15canvas));
if (canvas != NULL) {
g15r_initCanvas(canvas);
} else {
printf("Unable to initialise the libg15render canvas\nExiting\n");
return 1;
}
do {
dpy = XOpenDisplay(getenv("DISPLAY"));
if (!dpy) {
printf("Unable to open display %s - retrying\n",getenv("DISPLAY"));
sleep(2);
}
}while(!dpy);
/* completely ignore errors and carry on */
XSetErrorHandler(myx_error_handler);
// Get keycodes for all keys
strcpy(GKeyCodeCfg,configDir);
strncat(GKeyCodeCfg,"GKeyCodes.cfg",1024-strlen(GKeyCodeCfg));
printf("%s\n",GKeyCodeCfg);
getKeyDefs(GKeyCodeCfg);
configure_mmediakeys();
change_keymap(0);
XFlush(dpy);
if(keysonly>0)
goto close_and_exit;
/* old binary config format */
strncat(configpath,"/.g15macro",1024-strlen(configpath));
strncat(configpath,"/g15macro-data",1024-strlen(configpath));
config_fd = open(configpath,O_RDONLY|O_SYNC);
mstates[0] = malloc(sizeof(mstates_t));
mstates[1] = (mstates_t*)malloc(sizeof(mstates_t));
mstates[2] = (mstates_t*)malloc(sizeof(mstates_t));
if(config_fd>0) {
printf("Converting old data\n");
read(config_fd,mstates[0],sizeof(mstates_t));
read(config_fd,mstates[1],sizeof(mstates_t));
read(config_fd,mstates[2],sizeof(mstates_t));
close(config_fd);
strncpy(configpath,getenv("HOME"),1024);
strncat(configpath,"/.g15macro",1024-strlen(configpath));
char configbak[1024];
strcpy(configbak,configpath);
strncat(configpath,"/g15macro-data",1024-strlen(configpath));
strncat(configbak,"/g15macro-data.old",1024-strlen(configpath));
rename(configpath,configbak);
convert = 1;
}
else
cleanMstates(0); //0 = only NULL the pointers
/* new format */
strncpy(configpath,getenv("HOME"),1024);
strncat(configpath,"/.g15macro",1024-strlen(configpath));
mkdir(configpath,0777);
strncat(configpath,"/g15macro.conf",1024-strlen(configpath));
config=fopen(configpath,"a");
fclose(config);
do {
if((g15screen_fd = new_g15_screen(G15_G15RBUF))<0){
printf("Sorry, cant connect to the G15daemon - retrying\n");
sleep(2);
}
}while(g15screen_fd<0);
loadMultiConfig();
printf("I've now got the following macro files:\n");
for(i=0; i < MAX_CONFIGS;++i)
{
if(!configs[i])
continue;
printf("%i:%s%s\n",i,configDir,configs[i]->configfile);
}
if(!convert)
{
memset(configpath,0,sizeof(configpath));
strcpy(configpath,configDir);
strncat(configpath,configs[currConfig]->configfile,1024-strlen(configpath));
restore_config(configpath);
}
if(dump){
printf("G15Macro Dumping Codes...");
dump_config(stderr);
exit(0);
}
g15_send_cmd (g15screen_fd,G15DAEMON_KEY_HANDLER, dummy);
usleep(1000);
g15_send_cmd (g15screen_fd,G15DAEMON_MKEYLEDS,mled_state);
usleep(1000);
root_win = DefaultRootWindow(dpy);
if (!root_win) {
printf("Cant find root window\n");
return 1;
}
have_xtest = False;
#ifdef HAVE_XTEST
#ifdef USE_XTEST
have_xtest = XTestQueryExtension(dpy, &dummy, &dummy, &xtest_major_version, &xtest_minor_version);
if(have_xtest == False || xtest_major_version < 2 || (xtest_major_version <= 2 && xtest_minor_version < 2))
{
printf("Warning: XTEST extension not supported by Xserver. This is not fatal.\nReverting to XSendEvent for keypress emulation\n");
}
#else //USE_XTEST
printf("XTest disabled by configure option. Using XSendEvent instead.\n");
#endif //USE_XTEST
#else //HAVE_XTEST
printf("XTest disabled by configure: no devel package was found. Using XSendEvent instead.\n");
#endif //HAVE_XTEST
printf("XTest enabled. Using XTest.\n");
new_action.sa_handler = g15macro_sighandler;
new_action.sa_flags = 0;
sigaction(SIGINT, &new_action, NULL);
sigaction(SIGQUIT, &new_action, NULL);
sigaction(SIGTERM, &new_action, NULL);
sigaction(SIGPIPE, &new_action, NULL);
sigaction(SIGHUP, &new_action, NULL);
// So that forked processes that die can actually die instead of going defunct.
struct sigaction act;
memset(&act,0,sizeof(act));
act.sa_handler = &cleanupChildren;
sigaction(SIGCHLD,&act,NULL);
snprintf((char*)splashpath,1024,"%s/%s",DATADIR,"g15macro/splash/g15macro.wbmp");
g15r_loadWbmpSplash(canvas, splashpath);
g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
// Following piece of code is not documented (what i could find anyway)
// But makes so that the user can never bring this screen to front.
// TODO: Document it
// #ifdef G15DAEMON_NEVER_SELECT
// g15_send_cmd (g15screen_fd, G15DAEMON_NEVER_SELECT, dummy);
// #endif
usleep(1000);
pthread_mutex_init(&x11mutex,NULL);
pthread_mutex_init(&config_mutex,NULL);
pthread_mutex_init(&gui_select,NULL);
pthread_attr_t attr;
pthread_attr_init(&attr);
int thread_policy=SCHED_FIFO;
pthread_attr_setschedpolicy(&attr,thread_policy);
pthread_attr_setstacksize(&attr,32*1024); /* set stack to 32k - dont need 8Mb !! */
pthread_create(&Xkeys, &attr, xevent_thread, NULL);
pthread_create(&Lkeys, &attr, Lkeys_thread, NULL);
mainLoop();
cleanup();
close_and_exit:
/* XCloseDisplay(dpy); */
return 0;
}
void *Lkeys_thread() {
unsigned long keystate = 0;
struct pollfd fds;
char ver[5];
int foo = 0;
float g15v;
memset(ver,0x0,sizeof(ver));
strncpy(ver,G15DAEMON_VERSION,3);
sscanf(ver,"%f",&g15v);
g15macro_log("Using version %.2f as keypress protocol\n",g15v);
while(!leaving){
/* g15daemon series 1.2 need key request packets */
if((g15v*10)<=18) {
keystate = g15_send_cmd (g15screen_fd, G15DAEMON_GET_KEYSTATE, foo);
} else {
fds.fd = g15screen_fd;
fds.events = POLLIN;
fds.revents=0;
keystate=0;
if ((poll(&fds, 1, 1000)) > 0) {
read (g15screen_fd, &keystate, sizeof (keystate));
}
}
if (keystate!=0)
{
g15macro_log("Received Keystate == %lu\n",keystate);
switch (keystate)
{
case G15_KEY_L2:
{
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
if(!fg_check)
break;
// Go to default/g15macro.conf = id =0
gui_selectChange(0);
break;
}
case G15_KEY_L3:
{
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
if(!fg_check)
break;
// Scroll up
gui_selectChange(-1);
break;
}
case G15_KEY_L4:
{
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
if(!fg_check)
break;
// Scroll down
gui_selectChange(+1);
break;
}
case G15_KEY_L5:
{
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
if(!fg_check)
break;
// Change to selected
char newConfig[1024];
memset(newConfig,0,sizeof(newConfig));
strcpy(newConfig,configDir);
strncat(newConfig,configs[currConfig]->configfile,sizeof(newConfig)-strlen(newConfig));
// Actually not the newConfig, it's the old, but didn't come up with a good name.
save_macros(newConfig);
// Purge all old data
cleanMstates(1);
// Now load the new config
currConfig = gui_selectConfig;
memset(newConfig,0,sizeof(newConfig));
strcpy(newConfig,configDir);
strncat(newConfig,configs[currConfig]->configfile,sizeof(newConfig)-strlen(newConfig));
restore_config(newConfig);
// Set the configpath to reflect the change
memset(configpath,0,sizeof(configpath));
strcpy(configpath,configDir);
strncat(configpath,configs[currConfig]->configfile,sizeof(configpath)-strlen(configpath));
gui_oldConfig = MAX_CONFIGS+1;
break;
}
case G15_KEY_MR: {
g15macro_log("Key pressed is MR\n");
if(!recording) {
if(0==g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo)){
usleep(1000);
g15_send_cmd (g15screen_fd, G15DAEMON_SWITCH_PRIORITIES, foo);
g15macro_log("Switching to LCD foreground\n");
}
usleep(1000);
g15_send_cmd (g15screen_fd,G15DAEMON_MKEYLEDS, G15_LED_MR | mled_state);
g15r_initCanvas (canvas);
g15r_renderString (canvas, (unsigned char *)"Recording", 0, G15_TEXT_LARGE, 80-((strlen("Recording")/2)*8), 1);
g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
g15macro_log("Recording Enabled\n");
recording = 1;
pthread_mutex_lock(&x11mutex);
XGrabKeyboard(dpy, root_win, True, GrabModeAsync, GrabModeAsync, CurrentTime);
pthread_mutex_unlock(&x11mutex);
memset(¤t_recording,0,sizeof(current_recording));
} else {
record_cancel();
g15_send_cmd (g15screen_fd,G15DAEMON_MKEYLEDS,mled_state);
}
break;
}
case G15_KEY_M1:
handle_mkey_switch(G15_KEY_M1);
g15macro_log("Key pressed is M1\n");
break;
case G15_KEY_M2:
handle_mkey_switch(G15_KEY_M2);
g15macro_log("Key pressed is M2\n");
break;
case G15_KEY_M3:
handle_mkey_switch(G15_KEY_M3);
g15macro_log("Key pressed is M3\n");
break;
default:
if(keystate >=G15_KEY_G1 && keystate <=G15_KEY_G18){
if(recording==1){
record_complete(keystate);
} else {
macro_playback(keystate);
}
}
break;
}
keystate = 0;
}
}
return NULL;
}
