static void
move_cursor_forward(InputItem *sym)
{
if (sym->curr_line->buff_pntr == sym->curr_line->len &&
!sym->curr_line->next) {
BeepAtTheUser();
return;
}
if (sym->curr_line->buff_pntr == sym->curr_line->len ||
sym->curr_line->buff_pntr == sym->size - 1)
{
/* I have to move down to a new line */
if (sym->curr_line->next == NULL) {
/* now where to move */
BeepAtTheUser();
return;
}
/* move down line */
clear_cursor(sym);
sym->curr_line = sym->curr_line->next;
sym->curr_line->buff_pntr = 0;
}
else {
clear_cursor(sym);
sym->curr_line->buff_pntr++;
}
draw_cursor(sym);
}
static void
move_cursor_backward(InputItem *sym)
{
if (sym->curr_line->buff_pntr == 0) {
if (sym->curr_line->prev == NULL) {
/* now where to move */
BeepAtTheUser();
return;
}
else {
clear_cursor(sym);
/* move up to the previous line */
sym->curr_line = sym->curr_line->prev;
if (sym->curr_line->len > sym->size)
sym->curr_line->buff_pntr = sym->size - 1;
else
sym->curr_line->buff_pntr = sym->curr_line->len;
}
}
else { /* just slide back a char. on the current
* line */
clear_cursor(sym);
sym->curr_line->buff_pntr--;
}
draw_cursor(sym);
}
/* draws the toggled spots */
static void flipit_toggle(void)
{
spots[cursor_pos] = 1-spots[cursor_pos];
toggle[cursor_pos] = 1-toggle[cursor_pos];
draw_spot(cursor_pos);
if (cursor_pos%5 > 0) {
spots[cursor_pos-1] = 1-spots[cursor_pos-1];
draw_spot(cursor_pos-1);
}
if (cursor_pos%5 < 4) {
spots[cursor_pos+1] = 1-spots[cursor_pos+1];
draw_spot(cursor_pos+1);
}
if (cursor_pos/5 > 0) {
spots[cursor_pos-5] = 1-spots[cursor_pos-5];
draw_spot(cursor_pos-5);
}
if (cursor_pos/5 < 3) {
spots[cursor_pos+5] = 1-spots[cursor_pos+5];
draw_spot(cursor_pos+5);
}
moves++;
draw_info_panel();
if (flipit_finished())
clear_cursor();
}
static void
move_cursor_up(InputItem *sym)
{
int bp = sym->curr_line->buff_pntr;
/*int size = sym->size;*/
LineStruct *trace;
/* get to the end of the current line */
for (trace = sym->curr_line;
trace->prev && trace->prev->len > sym->size;
trace = trace->prev)
;
if (!trace->prev)
BeepAtTheUser();
else {
clear_cursor(sym);
sym->curr_line = trace->prev;
if (bp > sym->curr_line->len)
sym->curr_line->buff_pntr = sym->curr_line->len;
else
sym->curr_line->buff_pntr = bp;
draw_cursor(sym);
}
}
int main (int argc, const char * argv[]) {
FILE *fl = fopen(argv[1], "r");
FILE *out = fopen("/tmp/out.json", "w");
fseek(fl, 0, SEEK_END);
int file_size = ftell(fl);
printf("File size: %d\n", file_size);
fseek(fl, 0, SEEK_SET);
int index = 0;
Cursor* cursor = alloc_cursor();
clear_cursor(cursor);
cursor->position = -1;
read_osm_header(cursor, fl);
OsmItem* item;
do {
item = read_osm_item(cursor, fl, file_size);
if (item) {
char* json_item_txt = encode_item(item);
fputs(json_item_txt, out);
free(json_item_txt);
fputs("\n", out);
}
index += 1;
} while (item != NULL);
free_cursor(cursor);
fclose(fl);
fclose(out);
}
/* check if the puzzle is finished */
static bool flipit_finished(void)
{
int i;
for (i=0; i<20; i++)
if (!spots[i])
return false;
clear_cursor();
return true;
}
/* move the cursor in any direction */
static void move_cursor(int x, int y)
{
if (!(flipit_finished())) {
clear_cursor();
cursor_pos = ( x + 5 + cursor_pos%5 )%5
+ ( ( y + 4 + cursor_pos/5 )%4 )*5;
draw_cursor();
}
rb->lcd_update();
}
static void
move_cursor_end(InputItem *sym)
{
LineStruct *trace = sym->curr_line;
/* now move the cursor to the beginning of the current line */
clear_cursor(sym);
for (; trace && trace->next && trace->len > sym->size;)
trace = trace->next;
sym->curr_line = trace;
trace->buff_pntr = trace->len;
draw_cursor(sym);
}
/* the main game loop */
static bool flipit_loop(void)
{
int i;
int button;
int lastbutton = BUTTON_NONE;
flipit_init();
while(true) {
button = rb->button_get(true);
switch (button) {
#ifdef FLIPIT_RC_QUIT
case FLIPIT_RC_QUIT:
#endif
case FLIPIT_QUIT:
/* get out of here */
return PLUGIN_OK;
case FLIPIT_SHUFFLE:
/* mix up the pieces */
flipit_init();
break;
case FLIPIT_SOLVE:
#ifdef FLIPIT_SOLVE_PRE
if (lastbutton != FLIPIT_SOLVE_PRE)
break;
#endif
/* solve the puzzle */
if (!flipit_finished()) {
for (i=0; i<20; i++)
if (!toggle[i]) {
clear_cursor();
cursor_pos = i;
flipit_toggle();
draw_cursor();
rb->lcd_update();
rb->sleep(HZ*2/3);
}
}
break;
case FLIPIT_STEP_BY_STEP:
#ifdef FLIPIT_STEP_PRE
if (lastbutton != FLIPIT_STEP_PRE)
break;
#endif
if (!flipit_finished()) {
for (i=0; i<20; i++)
if (!toggle[i]) {
clear_cursor();
cursor_pos = i;
flipit_toggle();
draw_cursor();
rb->lcd_update();
break;
}
}
break;
case FLIPIT_TOGGLE:
#ifdef FLIPIT_TOGGLE_PRE
if (lastbutton != FLIPIT_TOGGLE_PRE)
break;
#endif
/* toggle the pieces */
if (!flipit_finished()) {
flipit_toggle();
draw_cursor();
rb->lcd_update();
}
break;
case FLIPIT_LEFT:
move_cursor(-1, 0);
break;
case FLIPIT_RIGHT:
move_cursor(1, 0);
break;
/*move cursor though the entire field*/
#ifdef FLIPIT_SCROLLWHEEL
case FLIPIT_PREV:
case FLIPIT_PREV|BUTTON_REPEAT:
if ((cursor_pos)%5 == 0) {
move_cursor(-1, -1);
}
else {
move_cursor(-1, 0);
}
break;
case FLIPIT_NEXT:
case FLIPIT_NEXT|BUTTON_REPEAT:
if ((cursor_pos+1)%5 == 0) {
move_cursor(1, 1);
}
else {
move_cursor(1, 0);
}
break;
#endif
case FLIPIT_UP:
#ifdef FLIPIT_UP_PRE
if (lastbutton != FLIPIT_UP_PRE)
break;
#endif
move_cursor(0, -1);
break;
case FLIPIT_DOWN:
move_cursor(0, 1);
break;
default:
if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
return PLUGIN_USB_CONNECTED;
break;
}
if (button != BUTTON_NONE)
lastbutton = button;
}
}
static void
overwrite_buffer(char *buffer, InputItem *item)
{
LineStruct *newline;
LineStruct *addline = item->curr_line;
/*int bufflen = strlen(buffer);*/
int nl = 0;
int cursor_y;
int size = item->size;
/* add a single character */
cursor_y = (addline->line_number - 1) * line_height;
if (addline->buff_pntr == size) {
clear_cursor(item);
if (addline->len <= size) {
nl = 1;
addline->buffer[size] = '_';
addline->buffer[size + 1] = 0;
addline->len = size + 1;
newline = (LineStruct *) alloc_inputline(size + 2);
newline->line_number = addline->line_number + 1;
inc_line_numbers(addline->next);
newline->next = addline->next;
newline->prev = addline;
if (addline->next)
addline->next->prev = newline;
addline->next = newline;
item->num_lines++;
cursor_y += line_height;
item->curr_line = addline = newline;
}
else {
item->curr_line = addline = addline->next;
}
addline->len = 1;
addline->buff_pntr = 1;
addline->buffer[0] = buffer[0];
}
else {
addline->buffer[addline->buff_pntr] = buffer[0];
clear_cursor(item);
if (++addline->buff_pntr > addline->len)
addline->len++;
}
/* now set up the current line */
if (item->curr_line->buff_pntr >= item->size &&
item->curr_line->next != NULL && !item->curr_line->next->len) {
/* I should actually be on the next line */
item->curr_line->buffer[item->size] = '_';
item->curr_line->len = item->size + 1;
XDrawString(gXDisplay, item->win, gWindow->fInputGC, start_x,
cursor_y + start_y,
addline->buffer,
addline->len);
item->curr_line = item->curr_line->next;
item->curr_line->buff_pntr = 0;
item->curr_line->changed = 1;
}
if (!nl) {
XDrawString(gXDisplay, item->win, gWindow->fInputGC, start_x,
cursor_y + start_y,
addline->buffer,
addline->len);
draw_cursor(item);
}
else
redraw_win();
}
void mgm::Display::configure(mg::DisplayConfiguration const& conf)
{
if (!conf.valid())
{
BOOST_THROW_EXCEPTION(
std::logic_error("Invalid or inconsistent display configuration"));
}
{
std::lock_guard<std::mutex> lg{configuration_mutex};
auto const& kms_conf = dynamic_cast<RealKMSDisplayConfiguration const&>(conf);
// Treat the current_display_configuration as incompatible with itself,
// before it's fully constructed, to force proper initialization.
bool const comp{(&conf != ¤t_display_configuration) &&
compatible(kms_conf, current_display_configuration)};
std::vector<std::unique_ptr<DisplayBuffer>> display_buffers_new;
if (!comp)
{
/*
* Notice for a little while here we will have duplicate
* DisplayBuffers attached to each output, and the display_buffers_new
* will take over the outputs before the old display_buffers are
* destroyed. So to avoid page flipping confusion in-between, make
* sure we wait for all pending page flips to finish before the
* display_buffers_new are created and take control of the outputs.
*/
for (auto& db : display_buffers)
db->wait_for_page_flip();
/* Reset the state of all outputs */
kms_conf.for_each_output([&](DisplayConfigurationOutput const& conf_output)
{
uint32_t const connector_id = current_display_configuration.get_kms_connector_id(conf_output.id);
auto kms_output = output_container.get_kms_output_for(connector_id);
kms_output->clear_cursor();
kms_output->reset();
});
}
/* Set up used outputs */
OverlappingOutputGrouping grouping{conf};
auto group_idx = 0;
grouping.for_each_group([&](OverlappingOutputGroup const& group)
{
auto bounding_rect = group.bounding_rectangle();
std::vector<std::shared_ptr<KMSOutput>> kms_outputs;
MirOrientation orientation = mir_orientation_normal;
group.for_each_output([&](DisplayConfigurationOutput const& conf_output)
{
uint32_t const connector_id = kms_conf.get_kms_connector_id(conf_output.id);
auto kms_output = output_container.get_kms_output_for(connector_id);
auto const mode_index = kms_conf.get_kms_mode_index(conf_output.id,
conf_output.current_mode_index);
kms_output->configure(conf_output.top_left - bounding_rect.top_left, mode_index);
if (!comp)
{
kms_output->set_power_mode(conf_output.power_mode);
kms_outputs.push_back(kms_output);
}
/*
* Presently OverlappingOutputGroup guarantees all grouped
* outputs have the same orientation.
*/
orientation = conf_output.orientation;
});
if (comp)
{
display_buffers[group_idx++]->set_orientation(orientation, bounding_rect);
}
else
{
uint32_t width = bounding_rect.size.width.as_uint32_t();
uint32_t height = bounding_rect.size.height.as_uint32_t();
if (orientation == mir_orientation_left ||
orientation == mir_orientation_right)
{
std::swap(width, height);
}
auto surface = gbm->create_scanout_surface(width, height);
std::unique_ptr<DisplayBuffer> db{
new DisplayBuffer{bypass_option,
drm,
gbm,
listener,
kms_outputs,
std::move(surface),
bounding_rect,
orientation,
*gl_config,
shared_egl.context()}};
display_buffers_new.push_back(std::move(db));
}
});
if (!comp)
display_buffers = std::move(display_buffers_new);
/* Store applied configuration */
current_display_configuration = kms_conf;
if (!comp)
/* Clear connected but unused outputs */
clear_connected_unused_outputs();
}
if (auto c = cursor.lock()) c->resume();
}
