static int combi_mode_init ( Mode *sw )
{
if ( mode_get_private_data ( sw ) == NULL ) {
CombiModePrivateData *pd = g_malloc0 ( sizeof ( *pd ) );
mode_set_private_data ( sw, (void *) pd );
combi_mode_parse_switchers ( sw );
pd->starts = g_malloc0 ( sizeof ( int ) * pd->num_switchers );
pd->lengths = g_malloc0 ( sizeof ( int ) * pd->num_switchers );
for ( unsigned int i = 0; i < pd->num_switchers; i++ ) {
if ( !mode_init ( pd->switchers[i] ) ) {
return FALSE;
}
}
if ( pd->cmd_list_length == 0 ) {
pd->cmd_list_length = 0;
for ( unsigned int i = 0; i < pd->num_switchers; i++ ) {
unsigned int length = mode_get_num_entries ( pd->switchers[i] );
pd->starts[i] = pd->cmd_list_length;
pd->lengths[i] = length;
pd->cmd_list_length += length;
}
}
}
return TRUE;
}
int dmenu_switcher_dialog ( void )
{
mode_init ( &dmenu_mode );
MenuFlags menu_flags = MENU_NORMAL;
DmenuModePrivateData *pd = (DmenuModePrivateData *) dmenu_mode.private_data;
char *input = NULL;
unsigned int cmd_list_length = pd->cmd_list_length;
char **cmd_list = pd->cmd_list;
pd->only_selected = FALSE;
if ( find_arg ( "-markup-rows" ) >= 0 ) {
pd->do_markup = TRUE;
}
if ( find_arg ( "-only-match" ) >= 0 || find_arg ( "-no-custom" ) >= 0 ) {
pd->only_selected = TRUE;
if ( cmd_list_length == 0 ) {
return TRUE;
}
}
if ( config.auto_select && cmd_list_length == 1 ) {
dmenu_output_formatted_line ( pd->format, cmd_list[0], 0, config.filter );
return TRUE;
}
if ( find_arg ( "-password" ) >= 0 ) {
menu_flags |= MENU_PASSWORD;
}
/* copy filter string */
input = g_strdup ( config.filter );
char *select = NULL;
find_arg_str ( "-select", &select );
if ( select != NULL ) {
char **tokens = tokenize ( select, config.case_sensitive );
unsigned int i = 0;
for ( i = 0; i < cmd_list_length; i++ ) {
if ( token_match ( tokens, cmd_list[i], !g_str_is_ascii ( cmd_list[i] ), config.case_sensitive ) ) {
pd->selected_line = i;
break;
}
}
g_strfreev ( tokens );
}
if ( find_arg ( "-dump" ) >= 0 ) {
char **tokens = tokenize ( config.filter ? config.filter : "", config.case_sensitive );
unsigned int i = 0;
for ( i = 0; i < cmd_list_length; i++ ) {
if ( token_match ( tokens, cmd_list[i], !g_str_is_ascii ( cmd_list[i] ), config.case_sensitive ) ) {
dmenu_output_formatted_line ( pd->format, cmd_list[i], i, config.filter );
}
}
g_strfreev ( tokens );
return TRUE;
}
// TODO remove
RofiViewState *state = rofi_view_create ( &dmenu_mode, input, pd->prompt, pd->message, menu_flags, dmenu_finalize );
rofi_view_set_selected_line ( state, pd->selected_line );
rofi_view_set_active ( state );
return FALSE;
}
// Public functions
// Initialize peripheral devices
void robockey_init(void)
{
m_clockdivide(0); // 16 MHz
sei(); // Enable global interrupt
timer1_init(0.5); // kHz
timer3_init(50); // Hz
//timer0_init(1); // kHz
adc_init();
mode_init();
m_rf_open(CHANNEL,RXADDRESS,PACKET_LENGTH_RF); // Enable wireless
m_usb_init(); // Enable usb communication
m_bus_init(); // Enable mbus
m_wii_open(); // Enable wii camera
}
static void run_switcher ( ModeMode mode )
{
pfd = setup ();
if ( pfd < 0 ) {
return;
}
// Otherwise check if requested mode is enabled.
for ( unsigned int i = 0; i < num_modi; i++ ) {
if ( !mode_init ( modi[i] ) ) {
rofi_view_error_dialog ( ERROR_MSG ( "Failed to initialize all the modi." ), ERROR_MSG_MARKUP );
teardown ( pfd );
return;
}
}
char *input = g_strdup ( config.filter );
__run_switcher_internal ( mode, input );
g_free ( input );
}
int main(void)
{
int test_mode;
int vm_present;
int i;
unsigned int seed;
// Needs to be called ASAP as rf need a looooooong time to wake up.
// This function is just sending a pulse over the SCL line.
rf_wakeup();
clock_set_speed(16000000UL,16);
setup_pps();
setup_io();
leds_init();
CHARGE_500MA = 0; // Switch back to 100mA charge.
// Switch on one led to say we are powered on
leds_set(LED_BATTERY_0, 32);
// Enable the poweroff softirq.
_INT3IF = 0;
_INT3IP = 1;
_INT3IE = 1;
// Sound must be enabled before analog, as
// The analog interrupt callback into sound processing ...
// But must be initialised _after_ leds as it use one led IO for enabling amp.
sound_init();
tone_init(); // Init tone generator
pwm_motor_init();
pid_motor_init();
// We need the settings for the horizontal prox.
load_settings_from_flash();
for (i = 0; i < 2; i++) {
// Settings is definitely wrong....
if(settings.mot256[i] <= 0)
settings.mot256[i] = 256;
// 1024 (AD resolution is 10 bits) * 256 / 9 fits in signed 16 bits.
if (settings.mot256[i] < 9)
settings.mot256[i] = 9;
}
// This is the horizontal prox. Vertical one are handled by the ADC
// but ADC sync the motor mesurment with the prox, so we don't pullute it with noise ...
timer_init(TIMER_IR_COMM, 0,-1); // The period will be changed later.
prox_init(PRIO_SENSORS); // Same priority as analog (maybe should be at 7 ...)
// Warning: We cannot use the SD before the analog init as some pin are on the analog port.
analog_init(TIMER_ANALOG, PRIO_SENSORS);
wait_valid_vbat();
log_init(); // We will need to read vbat to be sure we can flash.
ntc_init(ntc_callback, PRIO_1KHZ);
// i2c_init(I2C_3);
i2c_init_master(I2C_3, 400000, PRIO_I2C);
I2C3CON = 0x9000;
mma7660_init(I2C_3, MMA7660_DEFAULT_ADDRESS, acc_cb, 0);
mma7660_set_mode(MMA7660_120HZ, 1);
rc5_init(TIMER_RC5, rc5_callback, PRIO_RC5);
sd_init();
timer_init(TIMER_1KHZ, 1000, 6);
timer_enable_interrupt(TIMER_1KHZ, timer_1khz, PRIO_1KHZ);
rf_init(I2C_3);
timer_enable(TIMER_1KHZ);
sd_log_file();
vm_present = init_aseba_and_fifo();
if(vm_present)
log_analyse_bytecode();
vmVariables.fwversion[0] = FW_VERSION;
vmVariables.fwversion[1] = FW_VARIANT;
// SD file is more important than internal flash
if(!sd_load_aseba_code()) {
log_set_flag(LOG_FLAG_VMCODESD);
vm_present = 1;
log_analyse_bytecode();
}
// Behavior is on INT4 (softirq trigged by 1khz timer).
behavior_init(PRIO_BEHAVIOR);
test_mode = sd_test_file_present();
if(!test_mode)
mode_init(vm_present);
// Enable the LVD interrupt
_LVDIE = 1;
play_sound(SOUND_POWERON);
if(test_mode) {
test_mode_start();
while(1)
idle_without_aseba();
}
while(behavior_enabled(B_MODE))
idle_without_aseba();
// If usb did not put us out of behavior mode, then start the rf link
if(!usb_uart_serial_port_open() && (rf_get_status() & RF_PRESENT)) {
rf_set_link(RF_UP);
}
// get the random seed
seed = 0;
for(i = 0; i < 5; i++) {
seed += vmVariables.buttons_mean[i];
seed += vmVariables.buttons_noise[i];
}
seed += vmVariables.vbat[0];
seed += vmVariables.vbat[1];
for(i = 0; i < 3; i++)
seed += vmVariables.acc[i];
AsebaSetRandomSeed(seed);
for(i = 0; i < 3; i++)
AsebaGetRandom();
// Give full control to aseba. No way out (except reset).
run_aseba_main_loop();
}
int
main(int argc, char **argv)
{
int cfgresult;
int c;
/* set locale for cwdate & time formatting in chrono.c */
setlocale(LC_TIME, "");
/* get uname information */
if (uname(&unamebuf) == -1) {
perror("uname");
return (EXIT_FAILURE);
}
/* setup error handlers */
signal(SIGINT, exit_program); /* Ctrl-C */
signal(SIGTERM, exit_program); /* "regular" kill */
signal(SIGHUP, exit_program); /* kill -HUP */
signal(SIGPIPE, exit_program); /* write to closed socket */
signal(SIGKILL, exit_program); /* kill -9 [cannot be trapped; but ...] */
/* No error output from getopt */
opterr = 0;
/* get options from command line */
while ((c = getopt(argc, argv, "s:p:e:c:fhv")) > 0) {
char *end;
switch (c) {
/* c is for config file */
case 'c':
configfile = optarg;
break;
/* s is for server */
case 's':
server = optarg;
break;
/* p is for port */
case 'p':
port = strtol(optarg, &end, 0);
if ((*optarg == '\0') || (*end != '\0') ||
(port <= 0) || (port >= 0xFFFF)) {
fprintf(stderr, "Illegal port value %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'e':
islow = strtol(optarg, &end, 0);
if ((*optarg == '\0') || (*end != '\0') || (islow < 0)) {
fprintf(stderr, "Illegal delay value %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'f':
foreground = TRUE;
break;
case 'h':
HelpScreen(EXIT_SUCCESS);
break;
case 'v':
fprintf(stderr, "LCDproc %s\n", version);
exit(EXIT_SUCCESS);
break;
/* otherwise... Get help! */
case '?': /* unknown option or missing argument */
/* FALLTHROUGH */
default:
HelpScreen(EXIT_FAILURE);
break;
}
}
/* Read config file */
cfgresult = process_configfile(configfile);
if (cfgresult < 0) {
fprintf(stderr, "Error reading config file\n");
exit(EXIT_FAILURE);
}
/* Set default reporting options */
if (report_dest == UNSET_INT)
report_dest = DEFAULT_REPORTDEST;
if (report_level == UNSET_INT)
report_level = DEFAULT_REPORTLEVEL;
/* Set reporting settings */
set_reporting("lcdproc", report_level, report_dest);
/* parse non-option arguments: modes to add/delete */
if (argc > max(optind, 1)) {
int i;
/*
* if no config file was read, ignore hard coded default
* modes
*/
if (cfgresult == 0)
clear_modes();
/* turn additional options on or off (using ! as prefix) */
for (i = max(optind, 1); i < argc; i++) {
int state = (*argv[i] == '!') ? 0 : 1;
char *name = (state) ? argv[i] : argv[i] + 1;
int shortname = (strlen(name) == 1) ? name[0] : '\0';
int found = set_mode(shortname, name, state);
if (!found) {
fprintf(stderr, "Invalid Screen: %s\n", name);
return (EXIT_FAILURE);
}
}
}
if (server == NULL)
server = DEFAULT_SERVER;
/* Connect to the server... */
sock = sock_connect(server, port);
if (sock < 0) {
fprintf(stderr, "Error connecting to LCD server %s on port %d.\n"
"Check to see that the server is running and operating normally.\n",
server, port);
return (EXIT_FAILURE);
}
sock_send_string(sock, "hello\n");
usleep(500000); /* wait for the server to say hi. */
/* We grab the real values below, from the "connect" line. */
lcd_wid = 20;
lcd_hgt = 4;
lcd_cellwid = 5;
lcd_cellhgt = 8;
if (foreground != TRUE) {
if (daemon(1, 0) != 0) {
fprintf(stderr, "Error: daemonize failed\n");
return (EXIT_FAILURE);
}
if (pidfile != NULL) {
FILE *pidf = fopen(pidfile, "w");
if (pidf) {
fprintf(pidf, "%d\n", (int)getpid());
fclose(pidf);
pidfile_written = TRUE;
}
else {
fprintf(stderr, "Error creating pidfile %s: %s\n",
pidfile, strerror(errno));
return (EXIT_FAILURE);
}
}
}
/* Init the status gatherers... */
mode_init();
/* And spew stuff! */
main_loop();
exit_program(EXIT_SUCCESS);
/* NOTREACHED */
return EXIT_SUCCESS;
}
/* FIXME: All modules should get params from mod_dispatch */
static int init_modules(igd_param_t *params, igd_context_t *context)
{
unsigned int ret;
EMGD_TRACE_ENTER;
/*
* Reg module must be first so that the state of the device can be
* saved before anything else is touched.
*/
ret = REG_INIT(context, (params->preserve_regs)?IGD_DRIVER_SAVE_RESTORE:0);
if (ret) {
EMGD_DEBUG("Error initializing register module");
}
/*
* GMM is not optional. Its init function must exist.
*/
ret = gmm_init(context, params->page_request, params->max_fb_size);
if(ret) {
EMGD_ERROR_EXIT("GMM Module Init Failed");
return ret;
}
ret = CMD_INIT(context);
if(ret) {
EMGD_ERROR_EXIT("Command Module Init Failed");
return ret;
}
/*
* Mode is not optional. Its init function must exist.
*/
ret = mode_init(context);
if (ret) {
EMGD_ERROR_EXIT("Mode Module Init Failed");
return ret;
}
ret = APPCONTEXT_INIT(context);
if (ret) {
EMGD_ERROR_EXIT("Appcontext Module Init Failed");
return ret;
}
ret = OVERLAY_INIT(context, params);
if(ret) {
EMGD_ERROR_EXIT("Overlay Module Init Failed");
return ret;
}
ret = PWR_INIT(context);
if(ret) {
EMGD_DEBUG("Error initializing power module");
}
ret = RESET_INIT(context);
if(ret) {
EMGD_DEBUG("Error initializing reset module");
}
ret = OS_INIT_INTERRUPT(context->device_context.did,
context->device_context.virt_mmadr);
if(ret) {
EMGD_ERROR_EXIT("Interrupt Module Init Failed");
return ret;
}
ret = BLEND_INIT(context);
if(ret) {
EMGD_DEBUG("Error initializing blend module");
}
ret = INIT_2D(context);
if(ret) {
EMGD_DEBUG("Error initializing 2d module");
}
EMGD_TRACE_EXIT;
return 0;
}
static void
um_account_dialog_init (UmAccountDialog *self)
{
GtkBuilder *builder;
GtkWidget *widget;
const gchar *filename;
GError *error = NULL;
GtkDialog *dialog;
GtkWidget *content;
GtkWidget *actions;
GtkWidget *box;
builder = gtk_builder_new ();
filename = UIDIR "/account-dialog.ui";
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
filename = "data/account-dialog.ui";
if (!gtk_builder_add_from_file (builder, filename, &error)) {
g_error ("%s", error->message);
g_error_free (error);
return;
}
dialog = GTK_DIALOG (self);
actions = gtk_dialog_get_action_area (dialog);
content = gtk_dialog_get_content_area (dialog);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog), " ");
gtk_window_set_icon_name (GTK_WINDOW (dialog), "system-users");
/* Rearrange the bottom of dialog, so we can have spinner on left */
g_object_ref (actions);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_remove (GTK_CONTAINER (content), actions);
gtk_box_pack_end (GTK_BOX (box), actions, FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (content), box, TRUE, TRUE, 0);
gtk_widget_show (box);
g_object_unref (actions);
/* Create the spinner, but don't show it yet */
self->spinner = GTK_SPINNER (gtk_spinner_new ());
widget = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (widget), 0, 0, 12, 6);
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (self->spinner));
gtk_widget_show (widget);
gtk_dialog_add_button (dialog, _("Cancel"), GTK_RESPONSE_CANCEL);
widget = gtk_dialog_add_button (dialog, _("_Add"), GTK_RESPONSE_OK);
gtk_widget_grab_default (widget);
widget = (GtkWidget *) gtk_builder_get_object (builder, "account-dialog");
gtk_container_add (GTK_CONTAINER (content), widget);
self->container_widget = widget;
local_init (self, builder);
enterprise_init (self, builder);
join_init (self, builder);
mode_init (self, builder);
g_object_unref (builder);
}
