void
toolbar_client_show(Client *c)
{
Wm *w = c->wm;
long win_state;
c->mapped = True;
if (w->stack_top_app
&& (w->stack_top_app->flags & CLIENT_FULLSCREEN_FLAG))
main_client_manage_toolbars_for_fullscreen(c, True);
win_state = client_get_state(c);
if (win_state == WithdrawnState) /* initial show() state */
{
client_set_state(c,NormalState);
wm_update_layout(c->wm, c, - c->height);
}
else if (win_state == IconicState) /* minimised, set maximised */
{
client_set_state(c,NormalState);
/* Make sure desktop flag is unset */
c->flags &= ~CLIENT_IS_MINIMIZED;
wm_update_layout(c->wm, c, -(c->height - toolbar_win_offset(c)));
if (c->flags & CLIENT_TITLE_HIDDEN_FLAG)
{
c->x = wm_get_offsets_size(c->wm, WEST, NULL, False);
}
else
{
c->x = theme_frame_defined_width_get(w->mbtheme,
FRAME_UTILITY_MAX )
+ wm_get_offsets_size(c->wm, WEST, NULL, False);
c->y = c->y - ( c->height - toolbar_win_offset(c));
}
/* destroy buttons so they get recreated ok */
client_buttons_delete_all(c);
toolbar_client_move_resize(c);
toolbar_client_redraw(c, False);
}
stack_move_client_above_type(c, MBCLIENT_TYPE_APP|MBCLIENT_TYPE_DESKTOP);
XMapSubwindows(w->dpy, c->frame);
XMapWindow(w->dpy, c->frame);
comp_engine_client_show(w, c);
}
void
toolbar_client_hide(Client *c)
{
Wm *w = c->wm;
if (c->flags & CLIENT_IS_MINIMIZED || client_get_state(c) == IconicState)
return;
client_set_state(c,IconicState);
c->flags |= CLIENT_IS_MINIMIZED;
c->ignore_unmap++;
XUnmapWindow(w->dpy, c->window);
if (c->flags & CLIENT_TITLE_HIDDEN_FLAG)
{
XUnmapWindow(w->dpy, c->frame);
}
else
{
client_buttons_delete_all(c);
c->x = wm_get_offsets_size(c->wm, WEST, NULL, False);
c->y = c->y + c->height
- theme_frame_defined_height_get(c->wm->mbtheme, FRAME_UTILITY_MIN);
}
toolbar_client_move_resize(c);
toolbar_client_redraw(c, False);
dbg("hiding toolbar y is now %i", c->y);
wm_update_layout(c->wm, c, c->height - toolbar_win_offset(c));
}
// Ensure that client has a connection associated
int client_prep_connection(struct client *cl,
int operation_timeout, int session_timeout,
iochan_man_t iochan_man,
const struct timeval *abstime)
{
struct connection *co;
struct session_database *sdb = client_get_database(cl);
const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
const char *url = session_setting_oneval(sdb, PZ_URL);
const char *sru = session_setting_oneval(sdb, PZ_SRU);
struct host *host = 0;
int default_port = *sru ? 80 : 210;
if (zproxy && zproxy[0] == '\0')
zproxy = 0;
if (!url || !*url)
url = sdb->database->id;
host = find_host(client_get_session(cl)->service->server->database_hosts,
url, zproxy, default_port, iochan_man);
yaz_log(YLOG_DEBUG, "client_prep_connection: target=%s url=%s",
client_get_id(cl), url);
if (!host)
return 0;
co = client_get_connection(cl);
if (co)
{
assert(co->host);
if (co->host == host && client_get_state(cl) == Client_Idle)
{
return 2;
}
client_incref(cl);
connection_release(co);
co = 0;
}
if (!co)
{
int max_connections = 0;
int reuse_connections = 1;
const char *v = session_setting_oneval(client_get_database(cl),
PZ_MAX_CONNECTIONS);
if (v && *v)
max_connections = atoi(v);
v = session_setting_oneval(client_get_database(cl),
PZ_REUSE_CONNECTIONS);
if (v && *v)
reuse_connections = atoi(v);
// See if someone else has an idle connection
// We should look at timestamps here to select the longest-idle connection
yaz_mutex_enter(host->mutex);
while (1)
{
int num_connections = 0;
for (co = host->connections; co; co = co->next)
num_connections++;
if (reuse_connections)
{
for (co = host->connections; co; co = co->next)
{
if (connection_is_idle(co) &&
(!co->client || client_get_state(co->client) == Client_Idle) &&
!strcmp(ZOOM_connection_option_get(co->link, "user"),
session_setting_oneval(client_get_database(cl),
PZ_AUTHENTICATION)))
{
if (zproxy == 0 && co->zproxy == 0)
break;
if (zproxy && co->zproxy && !strcmp(zproxy, co->zproxy))
break;
}
}
if (co)
{
yaz_log(YLOG_LOG, "num_connections = %d (reusing)", num_connections);
break;
}
}
if (max_connections <= 0 || num_connections < max_connections)
{
yaz_log(YLOG_LOG, "num_connections = %d (new); max = %d",
num_connections, max_connections);
break;
}
yaz_log(YLOG_LOG, "num_connections = %d (waiting) max = %d",
num_connections, max_connections);
if (yaz_cond_wait(host->cond_ready, host->mutex, abstime))
{
yaz_log(YLOG_LOG, "out of connections %s", client_get_id(cl));
client_set_state(cl, Client_Error);
yaz_mutex_leave(host->mutex);
return 0;
}
}
if (co)
{
yaz_log(YLOG_LOG, "%p Connection reuse. state: %d", co, co->state);
connection_release(co);
client_set_connection(cl, co);
co->client = cl;
/* ensure that connection is only assigned to this client
by marking the client non Idle */
client_set_state(cl, Client_Working);
yaz_mutex_leave(host->mutex);
co->operation_timeout = operation_timeout;
co->session_timeout = session_timeout;
/* tells ZOOM to reconnect if necessary. Disabled becuase
the ZOOM_connection_connect flushes the task queue */
ZOOM_connection_connect(co->link, 0, 0);
}
else
{
yaz_mutex_leave(host->mutex);
co = connection_create(cl, host, operation_timeout, session_timeout,
iochan_man);
}
assert(co->host);
}
if (co && co->link)
return 1;
else
return 0;
}
