void remove_icon(TrayWindow *traywin)
{
if (systray_profile)
fprintf(stderr,
"[%f] %s:%d win = %lu (%s)\n",
profiling_get_time(),
__FUNCTION__,
__LINE__,
traywin->win,
traywin->name);
Panel *panel = systray.area.panel;
// remove from our list
systray.list_icons = g_slist_remove(systray.list_icons, traywin);
fprintf(stderr, YELLOW "remove_icon: %lu (%s)" RESET "\n", traywin->win, traywin->name);
XSelectInput(server.display, traywin->win, NoEventMask);
if (traywin->damage)
XDamageDestroy(server.display, traywin->damage);
// reparent to root
XSync(server.display, False);
error = FALSE;
XErrorHandler old = XSetErrorHandler(window_error_handler);
XUnmapWindow(server.display, traywin->win);
XReparentWindow(server.display, traywin->win, server.root_win, 0, 0);
XDestroyWindow(server.display, traywin->parent);
XSync(server.display, False);
XSetErrorHandler(old);
stop_timeout(traywin->render_timeout);
stop_timeout(traywin->resize_timeout);
free(traywin->name);
if (traywin->image) {
imlib_context_set_image(traywin->image);
imlib_free_image_and_decache();
}
g_free(traywin);
// check empty systray
int count = 0;
GSList *l;
for (l = systray.list_icons; l; l = l->next) {
count++;
}
if (count == 0)
hide(&systray.area);
// Resize and redraw the systray
if (systray_profile)
fprintf(stderr,
BLUE "[%f] %s:%d trigger resize & redraw" RESET "\n",
profiling_get_time(),
__FUNCTION__,
__LINE__);
systray.area.resize_needed = TRUE;
panel->area.resize_needed = TRUE;
schedule_redraw(&systray.area);
refresh_systray = TRUE;
}
void remove_from_multi_timeout(timeout* t) {
multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t);
g_hash_table_remove(multi_timeouts, t);
mth->timeout_list = g_slist_remove(mth->timeout_list, t);
free(t->multi_timeout);
t->multi_timeout = 0;
if (g_slist_length(mth->timeout_list) == 1) {
timeout* last_timeout = mth->timeout_list->data;
mth->timeout_list = g_slist_remove(mth->timeout_list, last_timeout);
free(last_timeout->multi_timeout);
last_timeout->multi_timeout = 0;
g_hash_table_remove(multi_timeouts, last_timeout);
g_hash_table_remove(multi_timeouts, mth->parent_timeout);
mth->parent_timeout->multi_timeout = 0;
stop_timeout(mth->parent_timeout);
free(mth);
struct timespec cur_time, diff_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
int msec_to_expiration =
diff_time.tv_sec * 1000 + diff_time.tv_nsec / 1000000;
add_timeout_intern(msec_to_expiration, last_timeout->interval_msec,
last_timeout->_callback, last_timeout->arg,
last_timeout);
} else
update_multi_timeout_values(mth);
}
void cleanup_clock()
{
pango_font_description_free(time1_font_desc);
time1_font_desc = NULL;
pango_font_description_free(time2_font_desc);
time2_font_desc = NULL;
free(time1_format);
time1_format = NULL;
free(time2_format);
time2_format = NULL;
free(time_tooltip_format);
time_tooltip_format = NULL;
free(time1_timezone);
time1_timezone = NULL;
free(time2_timezone);
time2_timezone = NULL;
free(time_tooltip_timezone);
time_tooltip_timezone = NULL;
free(clock_lclick_command);
clock_lclick_command = NULL;
free(clock_rclick_command);
clock_rclick_command = NULL;
stop_timeout(clock_timeout);
clock_timeout = NULL;
}
void stop_tooltip_timeout()
{
if (g_tooltip.timeout) {
stop_timeout(g_tooltip.timeout);
g_tooltip.timeout = 0;
}
}
void stop_autohide_timeout(Panel* p)
{
if (p->autohide_timeout) {
stop_timeout(p->autohide_timeout);
p->autohide_timeout = 0;
}
}
void del_urgent(Task *tsk)
{
urgent_list = g_slist_remove(urgent_list, tsk);
if (!urgent_list) {
stop_timeout(urgent_timeout);
urgent_timeout = NULL;
}
}
static void cleanup(void)
{
while (timeout_list)
{
struct timeout *t = timeout_list->data;
gtk_timeout_remove(t->id);
stop_timeout(t);
}
cddb_quit();
}
void destroy_execp(void *obj)
{
Execp *execp = (Execp *)obj;
if (execp->frontend) {
// This is a frontend element
execp->backend->instances = g_list_remove_all(execp->backend->instances, execp);
free_and_null(execp->frontend);
remove_area(&execp->area);
free_area(&execp->area);
free_and_null(execp);
} else {
// This is a backend element
stop_timeout(execp->backend->timer);
execp->backend->timer = NULL;
if (execp->backend->icon) {
imlib_context_set_image(execp->backend->icon);
imlib_free_image();
execp->backend->icon = NULL;
}
free_and_null(execp->backend->buf_output);
free_and_null(execp->backend->text);
free_and_null(execp->backend->icon_path);
if (execp->backend->child) {
kill(-execp->backend->child, SIGHUP);
execp->backend->child = 0;
}
if (execp->backend->child_pipe >= 0) {
close(execp->backend->child_pipe);
execp->backend->child_pipe = -1;
}
if (execp->backend->cmd_pids) {
g_tree_destroy(execp->backend->cmd_pids);
execp->backend->cmd_pids = NULL;
}
execp->backend->bg = NULL;
pango_font_description_free(execp->backend->font_desc);
execp->backend->font_desc = NULL;
free_and_null(execp->backend->command);
free_and_null(execp->backend->tooltip);
free_and_null(execp->backend->lclick_command);
free_and_null(execp->backend->mclick_command);
free_and_null(execp->backend->rclick_command);
free_and_null(execp->backend->dwheel_command);
free_and_null(execp->backend->uwheel_command);
if (execp->backend->instances) {
fprintf(stderr, "Error: Attempt to destroy backend while there are still frontend instances!\n");
exit(-1);
}
free(execp->backend);
free(execp);
}
}
static void player_connect(Game * game)
{
gchar *location;
gint fd = accept_connection(game->accept_fd, &location);
if (fd > 0) {
if (player_new_connection(game, fd, location) != NULL)
stop_timeout(game);
}
g_free(location);
}
void execp_force_update(Execp *execp)
{
if (execp->backend->child_pipe > 0) {
// Command currently running, nothing to do
} else {
if (execp->backend->timer)
stop_timeout(execp->backend->timer);
// Run command right away
execp->backend->timer = add_timeout(10, 0, execp_timer_callback, execp, &execp->backend->timer);
}
}
void cleanup_clock()
{
if (time1_font_desc) pango_font_description_free(time1_font_desc);
if (time2_font_desc) pango_font_description_free(time2_font_desc);
if (time1_format) g_free(time1_format);
if (time2_format) g_free(time2_format);
if (time_tooltip_format) g_free(time_tooltip_format);
if (time1_timezone) g_free(time1_timezone);
if (time2_timezone) g_free(time2_timezone);
if (time_tooltip_timezone) g_free(time_tooltip_timezone);
if (clock_lclick_command) g_free(clock_lclick_command);
if (clock_rclick_command) g_free(clock_rclick_command);
if (clock_timeout) stop_timeout(clock_timeout);
}
void cleanup_panel()
{
if (!panels)
return;
cleanup_taskbar();
for (int i = 0; i < num_panels; i++) {
Panel *p = &panels[i];
free_area(&p->area);
if (p->temp_pmap)
XFreePixmap(server.display, p->temp_pmap);
p->temp_pmap = 0;
if (p->hidden_pixmap)
XFreePixmap(server.display, p->hidden_pixmap);
p->hidden_pixmap = 0;
if (p->main_win)
XDestroyWindow(server.display, p->main_win);
p->main_win = 0;
stop_timeout(p->autohide_timeout);
cleanup_freespace(p);
}
free(panel_items_order);
panel_items_order = NULL;
free(panel_window_name);
panel_window_name = NULL;
free(panels);
panels = NULL;
free_area(&panel_config.area);
if (backgrounds)
g_array_free(backgrounds, TRUE);
backgrounds = NULL;
if (gradients) {
for (guint i = 0; i < gradients->len; i++)
cleanup_gradient(&g_array_index(gradients, GradientClass, i));
g_array_free(gradients, TRUE);
}
gradients = NULL;
pango_font_description_free(panel_config.g_task.font_desc);
panel_config.g_task.font_desc = NULL;
pango_font_description_free(panel_config.taskbarname_font_desc);
panel_config.taskbarname_font_desc = NULL;
}
void execp_action(void *obj, int button, int x, int y)
{
Execp *execp = obj;
char *command = NULL;
switch (button) {
case 1:
command = execp->backend->lclick_command;
break;
case 2:
command = execp->backend->mclick_command;
break;
case 3:
command = execp->backend->rclick_command;
break;
case 4:
command = execp->backend->uwheel_command;
break;
case 5:
command = execp->backend->dwheel_command;
break;
}
if (command) {
char *full_cmd = g_strdup_printf("export EXECP_X=%d;"
"export EXECP_Y=%d;"
"export EXECP_W=%d;"
"export EXECP_H=%d; %s",
x,
y,
execp->area.width,
execp->area.height,
command);
tint_exec(full_cmd);
g_free(full_cmd);
} else {
if (execp->backend->child_pipe > 0) {
// Command currently running, nothing to do
} else {
if (execp->backend->timer)
stop_timeout(execp->backend->timer);
// Run command right away
execp->backend->timer = add_timeout(10, 0, execp_timer_callback, execp, &execp->backend->timer);
}
}
}
void cleanup_panel()
{
if (!panel1)
return;
cleanup_taskbar();
int i;
Panel *p;
for (i = 0; i < nb_panel; i++) {
p = &panel1[i];
free_area(&p->area);
if (p->temp_pmap)
XFreePixmap(server.dsp, p->temp_pmap);
p->temp_pmap = 0;
if (p->hidden_pixmap)
XFreePixmap(server.dsp, p->hidden_pixmap);
p->hidden_pixmap = 0;
if (p->main_win)
XDestroyWindow(server.dsp, p->main_win);
p->main_win = 0;
stop_timeout(p->autohide_timeout);
}
free(panel_items_order);
panel_items_order = NULL;
free(panel_window_name);
panel_window_name = NULL;
free(panel1);
panel1 = NULL;
if (backgrounds)
g_array_free(backgrounds, 1);
backgrounds = NULL;
pango_font_description_free(panel_config.g_task.font_desc);
panel_config.g_task.font_desc = NULL;
}
void systray_render_icon_composited(void *t)
{
// we end up in this function only in real transparency mode or if systray_task_asb != 100 0 0
// we made also sure, that we always have a 32 bit visual, i.e. we can safely create 32 bit pixmaps here
TrayWindow *traywin = t;
if (systray_profile)
fprintf(stderr,
"[%f] %s:%d win = %lu (%s)\n",
profiling_get_time(),
__FUNCTION__,
__LINE__,
traywin->win,
traywin->name);
// wine tray icons update whenever mouse is over them, so we limit the updates to 50 ms
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
struct timespec earliest_render = add_msec_to_timespec(traywin->time_last_render, min_refresh_period);
if (compare_timespecs(&earliest_render, &now) > 0) {
traywin->num_fast_renders++;
if (traywin->num_fast_renders > max_fast_refreshes) {
traywin->render_timeout =
add_timeout(min_refresh_period, 0, systray_render_icon_composited, traywin, &traywin->render_timeout);
if (systray_profile)
fprintf(stderr,
YELLOW "[%f] %s:%d win = %lu (%s) delaying rendering" RESET "\n",
profiling_get_time(),
__FUNCTION__,
__LINE__,
traywin->win,
traywin->name);
return;
}
} else {
traywin->time_last_render.tv_sec = now.tv_sec;
traywin->time_last_render.tv_nsec = now.tv_nsec;
traywin->num_fast_renders = 0;
}
if (traywin->width == 0 || traywin->height == 0) {
// reschedule rendering since the geometry information has not yet been processed (can happen on slow cpu)
traywin->render_timeout =
add_timeout(min_refresh_period, 0, systray_render_icon_composited, traywin, &traywin->render_timeout);
if (systray_profile)
fprintf(stderr,
YELLOW "[%f] %s:%d win = %lu (%s) delaying rendering" RESET "\n",
profiling_get_time(),
__FUNCTION__,
__LINE__,
traywin->win,
traywin->name);
return;
}
if (traywin->render_timeout) {
stop_timeout(traywin->render_timeout);
traywin->render_timeout = NULL;
}
// good systray icons support 32 bit depth, but some icons are still 24 bit.
// We create a heuristic mask for these icons, i.e. we get the rgb value in the top left corner, and
// mask out all pixel with the same rgb value
// Very ugly hack, but somehow imlib2 is not able to get the image from the traywindow itself,
// so we first render the tray window onto a pixmap, and then we tell imlib2 to use this pixmap as
// drawable. If someone knows why it does not work with the traywindow itself, please tell me ;)
Pixmap tmp_pmap = XCreatePixmap(server.display, traywin->win, traywin->width, traywin->height, 32);
if (!tmp_pmap) {
goto on_systray_error;
}
XRenderPictFormat *f;
if (traywin->depth == 24) {
f = XRenderFindStandardFormat(server.display, PictStandardRGB24);
} else if (traywin->depth == 32) {
f = XRenderFindStandardFormat(server.display, PictStandardARGB32);
} else {
fprintf(stderr, RED "Strange tray icon found with depth: %d" RESET "\n", traywin->depth);
XFreePixmap(server.display, tmp_pmap);
return;
}
XRenderPictFormat *f32 = XRenderFindVisualFormat(server.display, server.visual32);
if (!f || !f32) {
XFreePixmap(server.display, tmp_pmap);
goto on_systray_error;
}
XSync(server.display, False);
error = FALSE;
XErrorHandler old = XSetErrorHandler(window_error_handler);
// if (server.real_transparency)
// Picture pict_image = XRenderCreatePicture(server.display, traywin->parent, f, 0, 0);
// reverted Rev 407 because here it's breaking alls icon with systray + xcompmgr
Picture pict_image = XRenderCreatePicture(server.display, traywin->win, f, 0, 0);
if (!pict_image) {
XFreePixmap(server.display, tmp_pmap);
XSetErrorHandler(old);
goto on_error;
}
Picture pict_drawable =
XRenderCreatePicture(server.display, tmp_pmap, XRenderFindVisualFormat(server.display, server.visual32), 0, 0);
if (!pict_drawable) {
XRenderFreePicture(server.display, pict_image);
XFreePixmap(server.display, tmp_pmap);
XSetErrorHandler(old);
goto on_error;
}
XRenderComposite(server.display,
PictOpSrc,
pict_image,
None,
pict_drawable,
0,
0,
0,
0,
0,
0,
traywin->width,
traywin->height);
XRenderFreePicture(server.display, pict_image);
XRenderFreePicture(server.display, pict_drawable);
// end of the ugly hack and we can continue as before
imlib_context_set_visual(server.visual32);
imlib_context_set_colormap(server.colormap32);
imlib_context_set_drawable(tmp_pmap);
Imlib_Image image = imlib_create_image_from_drawable(0, 0, 0, traywin->width, traywin->height, 1);
imlib_context_set_visual(server.visual);
imlib_context_set_colormap(server.colormap);
XFreePixmap(server.display, tmp_pmap);
if (!image) {
imlib_context_set_visual(server.visual);
imlib_context_set_colormap(server.colormap);
XSetErrorHandler(old);
goto on_error;
} else {
if (traywin->image) {
imlib_context_set_image(traywin->image);
imlib_free_image_and_decache();
}
traywin->image = image;
}
imlib_context_set_image(traywin->image);
// if (traywin->depth == 24)
// imlib_save_image("/home/thil77/test.jpg");
imlib_image_set_has_alpha(1);
DATA32 *data = imlib_image_get_data();
if (traywin->depth == 24) {
create_heuristic_mask(data, traywin->width, traywin->height);
}
if (systray.alpha != 100 || systray.brightness != 0 || systray.saturation != 0)
adjust_asb(data,
traywin->width,
traywin->height,
systray.alpha,
(float)systray.saturation / 100,
(float)systray.brightness / 100);
imlib_image_put_back_data(data);
systray_render_icon_from_image(traywin);
if (traywin->damage)
XDamageSubtract(server.display, traywin->damage, None, None);
XSync(server.display, False);
XSetErrorHandler(old);
if (error)
goto on_error;
panel_refresh = TRUE;
if (systray_profile)
fprintf(stderr,
"[%f] %s:%d win = %lu (%s)\n",
profiling_get_time(),
__FUNCTION__,
__LINE__,
traywin->win,
traywin->name);
return;
on_error:
fprintf(stderr,
RED "systray %d: rendering error for icon %lu (%s) pid %d" RESET "\n",
__LINE__,
traywin->win,
traywin->name,
traywin->pid);
return;
on_systray_error:
fprintf(stderr,
RED "systray %d: rendering error for icon %lu (%s) pid %d. "
"Disabling compositing and restarting systray..." RESET "\n",
__LINE__,
traywin->win,
traywin->name,
traywin->pid);
systray_composited = 0;
stop_net();
start_net();
return;
}
void systray_reconfigure_event(TrayWindow *traywin, XEvent *e)
{
if (systray_profile)
fprintf(stderr,
"XConfigure event: win = %lu (%s), x = %d, y = %d, w = %d, h = %d\n",
traywin->win,
traywin->name,
e->xconfigure.x,
e->xconfigure.y,
e->xconfigure.width,
e->xconfigure.height);
if (!traywin->reparented)
return;
if (e->xconfigure.width != traywin->width || e->xconfigure.height != traywin->height || e->xconfigure.x != 0 ||
e->xconfigure.y != 0) {
if (traywin->bad_size_counter < max_bad_resize_events) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
struct timespec earliest_resize = add_msec_to_timespec(traywin->time_last_resize, resize_period_threshold);
if (compare_timespecs(&earliest_resize, &now) > 0) {
// Fast resize, but below the threshold
traywin->bad_size_counter++;
} else {
// Slow resize, reset counter
traywin->time_last_resize.tv_sec = now.tv_sec;
traywin->time_last_resize.tv_nsec = now.tv_nsec;
traywin->bad_size_counter = 0;
}
if (traywin->bad_size_counter < min_bad_resize_events) {
systray_resize_icon(traywin);
} else {
if (!traywin->resize_timeout)
traywin->resize_timeout =
add_timeout(fast_resize_period, 0, systray_resize_icon, traywin, &traywin->resize_timeout);
}
} else {
if (traywin->bad_size_counter == max_bad_resize_events) {
traywin->bad_size_counter++;
fprintf(stderr,
RED "Detected resize loop for tray icon %lu (%s), throttling resize events" RESET "\n",
traywin->win,
traywin->name);
}
// Delayed resize
// FIXME Normally we should force the icon to resize fill_color to the size we resized it to when we
// embedded it.
// However this triggers a resize loop in new versions of GTK, which we must avoid.
if (!traywin->resize_timeout)
traywin->resize_timeout =
add_timeout(slow_resize_period, 0, systray_resize_icon, traywin, &traywin->resize_timeout);
return;
}
} else {
// Correct size
stop_timeout(traywin->resize_timeout);
}
// Resize and redraw the systray
if (systray_profile)
fprintf(stderr,
BLUE "[%f] %s:%d trigger resize & redraw" RESET "\n",
profiling_get_time(),
__FUNCTION__,
__LINE__);
panel_refresh = TRUE;
refresh_systray = TRUE;
}
void stop_tooltip_timeout()
{
stop_timeout(g_tooltip.timeout);
}
static uint32_t bl_evt_handler(bl_evt_t* p_evt)
{
static bl_cmd_t rsp_cmd;
bool respond = false;
switch (p_evt->type)
{
case BL_EVT_TYPE_DFU_ABORT:
bootloader_abort(p_evt->params.dfu.abort.reason);
/* If bootloader abort returned, it means that the application
* doesn't work, and we should return to the dfu operation. */
dfu_mesh_start();
break;
case BL_EVT_TYPE_TX_RADIO:
{
mesh_packet_t* p_packet = NULL;
if (!mesh_packet_acquire(&p_packet))
{
return NRF_ERROR_NO_MEM;
}
mesh_packet_set_local_addr(p_packet);
p_packet->header.type = BLE_PACKET_TYPE_ADV_NONCONN_IND;
p_packet->header.length = DFU_PACKET_OVERHEAD + p_evt->params.tx.radio.length;
((ble_ad_t*) p_packet->payload)->adv_data_type = MESH_ADV_DATA_TYPE;
((ble_ad_t*) p_packet->payload)->data[0] = (MESH_UUID & 0xFF);
((ble_ad_t*) p_packet->payload)->data[1] = (MESH_UUID >> 8) & 0xFF;
((ble_ad_t*) p_packet->payload)->adv_data_length = DFU_PACKET_ADV_OVERHEAD + p_evt->params.tx.radio.length;
memcpy(&p_packet->payload[4], p_evt->params.tx.radio.p_dfu_packet, p_evt->params.tx.radio.length);
bool success = transport_tx(p_packet,
p_evt->params.tx.radio.tx_slot,
p_evt->params.tx.radio.tx_count,
(tx_interval_type_t) p_evt->params.tx.radio.interval_type);
mesh_packet_ref_count_dec(p_packet);
if (!success)
{
return NRF_ERROR_INTERNAL;
}
break;
}
case BL_EVT_TYPE_TX_ABORT:
transport_tx_abort(p_evt->params.tx.abort.tx_slot);
break;
case BL_EVT_TYPE_TX_SERIAL:
{
#ifdef RBC_MESH_SERIAL
serial_evt_t serial_evt;
serial_evt.opcode = SERIAL_EVT_OPCODE_DFU;
memcpy(&serial_evt.params.dfu.packet,
p_evt->params.tx.serial.p_dfu_packet,
p_evt->params.tx.serial.length);
serial_evt.length = SERIAL_PACKET_OVERHEAD + p_evt->params.tx.serial.length;
if (!serial_handler_event_send(&serial_evt))
{
return NRF_ERROR_INTERNAL;
}
break;
#endif
}
case BL_EVT_TYPE_TIMER_SET:
set_timeout(US_TO_RTC_TICKS(p_evt->params.timer.set.delay_us), TIMEOUT_ACTION_DFU_TIMEOUT);
break;
case BL_EVT_TYPE_DFU_NEW_FW:
{
stop_timeout();
__LOG("New FW event\n");
switch (p_evt->params.dfu.new_fw.fw_type)
{
case DFU_TYPE_APP:
__LOG("\tAPP: %08x.%04x:%08x\n",
(uint32_t) p_evt->params.dfu.new_fw.fwid.app.company_id,
(uint32_t) p_evt->params.dfu.new_fw.fwid.app.app_id,
(uint32_t) p_evt->params.dfu.new_fw.fwid.app.app_version);
break;
case DFU_TYPE_SD:
__LOG("\tSD: %04x\n",
(uint32_t) p_evt->params.dfu.new_fw.fwid.sd);
break;
case DFU_TYPE_BOOTLOADER:
__LOG("\tBL: %02x:%02x\n",
(uint32_t) p_evt->params.dfu.new_fw.fwid.bootloader.id,
(uint32_t) p_evt->params.dfu.new_fw.fwid.bootloader.ver);
break;
default: break;
}
/* accept all new firmware, as the bootloader wouldn't run
unless there's an actual reason for it. */
rsp_cmd.type = BL_CMD_TYPE_DFU_START_TARGET;
rsp_cmd.params.dfu.start.target.p_bank_start = (uint32_t*) 0xFFFFFFFF; /* no banking */
rsp_cmd.params.dfu.start.target.type = p_evt->params.dfu.new_fw.fw_type;
rsp_cmd.params.dfu.start.target.fwid = p_evt->params.dfu.new_fw.fwid;
respond = true;
}
break;
case BL_EVT_TYPE_BANK_AVAILABLE:
__LOG("Bank:\n");
switch (p_evt->params.bank_available.bank_dfu_type)
{
case DFU_TYPE_APP:
__LOG("\tAPP: %08x.%04x:%08x\n",
(uint32_t) p_evt->params.bank_available.bank_fwid.app.company_id,
(uint32_t) p_evt->params.bank_available.bank_fwid.app.app_id,
(uint32_t) p_evt->params.bank_available.bank_fwid.app.app_version);
break;
case DFU_TYPE_SD:
__LOG("\tSD: %04x\n",
(uint32_t) p_evt->params.bank_available.bank_fwid.sd);
break;
case DFU_TYPE_BOOTLOADER:
__LOG("\tBL: %02x:%02x\n",
(uint32_t) p_evt->params.bank_available.bank_fwid.bootloader.id,
(uint32_t) p_evt->params.bank_available.bank_fwid.bootloader.ver);
break;
default: break;
}
__LOG("\tLocation: 0x%x\n", p_evt->params.bank_available.p_bank_addr);
__LOG("\tLength: 0x%x\n", p_evt->params.bank_available.bank_length);
if (p_evt->params.bank_available.bank_dfu_type == DFU_TYPE_BOOTLOADER)
{
if (!dfu_mesh_app_is_valid())
{
dfu_bank_flash(DFU_TYPE_BOOTLOADER);
}
}
break;
case BL_EVT_TYPE_DFU_REQ:
{
/* Always attempt to relay incoming transfers in BL mode. Will
not abort ongoing transfers. */
if (p_evt->params.dfu.req.role == DFU_ROLE_RELAY)
{
stop_timeout();
bl_cmd_t relay_cmd;
relay_cmd.type = BL_CMD_TYPE_DFU_START_RELAY;
relay_cmd.params.dfu.start.relay.fwid = p_evt->params.dfu.req.fwid;
relay_cmd.params.dfu.start.relay.type = p_evt->params.dfu.req.dfu_type;
relay_cmd.params.dfu.start.relay.transaction_id = p_evt->params.dfu.req.transaction_id;
bootloader_cmd_send(&relay_cmd);
}
}
break;
case BL_EVT_TYPE_DFU_START:
set_timeout(TIMER_START_TIMEOUT, TIMEOUT_ACTION_DFU_ABORT);
break;
case BL_EVT_TYPE_DFU_DATA_SEGMENT_RX:
__LOG("RX %u/%u\n",
p_evt->params.dfu.data_segment.received_segment,
p_evt->params.dfu.data_segment.total_segments);
set_timeout(TIMER_DATA_TIMEOUT, TIMEOUT_ACTION_DFU_ABORT);
break;
case BL_EVT_TYPE_DFU_END:
if (p_evt->params.dfu.end.dfu_type == DFU_TYPE_APP ||
p_evt->params.dfu.end.dfu_type == DFU_TYPE_SD)
{
/* attempt to reboot to app */
bootloader_abort(DFU_END_SUCCESS);
}
break;
/* Defer the flash operations to an asynchronous handler. Doing it
inline causes stack overflow, as the bootloader continues in the
response callback. */
case BL_EVT_TYPE_FLASH_WRITE:
{
if (!IS_WORD_ALIGNED(p_evt->params.flash.write.start_addr) ||
!IS_WORD_ALIGNED(p_evt->params.flash.write.p_data))
{
return NRF_ERROR_INVALID_ADDR;
}
if (!IS_WORD_ALIGNED(p_evt->params.flash.write.length))
{
return NRF_ERROR_INVALID_LENGTH;
}
if ((p_evt->params.flash.write.start_addr + p_evt->params.flash.write.length) > NRF_UICR->BOOTLOADERADDR &&
p_evt->params.flash.write.start_addr < 0x3f800)
{
APP_ERROR_CHECK(NRF_ERROR_INVALID_ADDR);
}
flash_queue_entry_t queue_entry;
queue_entry.type = FLASH_OP_TYPE_WRITE;
memcpy(&queue_entry.op, &p_evt->params.flash, sizeof(flash_op_t));
if (fifo_push(&m_flash_fifo, &queue_entry) != NRF_SUCCESS)
{
__LOG(RTT_CTRL_TEXT_RED "FLASH FIFO FULL :( Increase the fifo size.\n");
return NRF_ERROR_NO_MEM;
}
NVIC_SetPendingIRQ(FLASH_HANDLER_IRQn);
}
break;
case BL_EVT_TYPE_FLASH_ERASE:
{
flash_queue_entry_t queue_entry;
queue_entry.type = FLASH_OP_TYPE_ERASE;
memcpy(&queue_entry.op, &p_evt->params.flash, sizeof(flash_op_t));
if (fifo_push(&m_flash_fifo, &queue_entry) != NRF_SUCCESS)
{
__LOG(RTT_CTRL_TEXT_RED "FLASH FIFO FULL :( Increase the fifo size.\n");
return NRF_ERROR_NO_MEM;
}
NVIC_SetPendingIRQ(FLASH_HANDLER_IRQn);
}
break;
default:
return NRF_ERROR_NOT_SUPPORTED;
}
if (respond)
{
/* tail recursion */
return bl_cmd_handler(&rsp_cmd);
}
else
{
return NRF_SUCCESS;
}
}
void systray_render_icon(void *t)
{
TrayWindow *traywin = t;
if (systray_profile)
fprintf(stderr,
"[%f] %s:%d win = %lu (%s)\n",
profiling_get_time(),
__FUNCTION__,
__LINE__,
traywin->win,
traywin->name);
if (!traywin->reparented || !traywin->embedded) {
if (systray_profile)
fprintf(stderr,
YELLOW "[%f] %s:%d win = %lu (%s) delaying rendering" RESET "\n",
profiling_get_time(),
__FUNCTION__,
__LINE__,
traywin->win,
traywin->name);
stop_timeout(traywin->render_timeout);
traywin->render_timeout =
add_timeout(min_refresh_period, 0, systray_render_icon, traywin, &traywin->render_timeout);
return;
}
if (systray_composited) {
XSync(server.display, False);
error = FALSE;
XErrorHandler old = XSetErrorHandler(window_error_handler);
unsigned int border_width;
int xpos, ypos;
unsigned int width, height, depth;
Window root;
if (!XGetGeometry(server.display, traywin->win, &root, &xpos, &ypos, &width, &height, &border_width, &depth)) {
stop_timeout(traywin->render_timeout);
if (!traywin->resize_timeout)
traywin->render_timeout =
add_timeout(min_refresh_period, 0, systray_render_icon, traywin, &traywin->render_timeout);
systray_render_icon_from_image(traywin);
XSetErrorHandler(old);
return;
} else {
if (xpos != 0 || ypos != 0 || width != traywin->width || height != traywin->height) {
stop_timeout(traywin->render_timeout);
if (!traywin->resize_timeout)
traywin->render_timeout =
add_timeout(min_refresh_period, 0, systray_render_icon, traywin, &traywin->render_timeout);
systray_render_icon_from_image(traywin);
if (systray_profile)
fprintf(stderr,
YELLOW "[%f] %s:%d win = %lu (%s) delaying rendering" RESET "\n",
profiling_get_time(),
__FUNCTION__,
__LINE__,
traywin->win,
traywin->name);
XSetErrorHandler(old);
return;
}
}
XSetErrorHandler(old);
}
if (systray_profile)
fprintf(stderr, "rendering tray icon\n");
if (systray_composited) {
systray_render_icon_composited(traywin);
} else {
// Trigger window repaint
if (systray_profile)
fprintf(stderr,
"XClearArea(server.display, traywin->parent = %ld, 0, 0, traywin->width, traywin->height, True)\n",
traywin->parent);
XClearArea(server.display, traywin->parent, 0, 0, 0, 0, True);
if (systray_profile)
fprintf(stderr,
"XClearArea(server.display, traywin->win = %ld, 0, 0, traywin->width, traywin->height, True)\n",
traywin->win);
XClearArea(server.display, traywin->win, 0, 0, 0, 0, True);
}
}
void stop_autohide_timeout(Panel *p)
{
stop_timeout(p->autohide_timeout);
}