static int
ProcXFixesQueryVersion(ClientPtr client)
{
XFixesClientPtr pXFixesClient = GetXFixesClient (client);
xXFixesQueryVersionReply rep;
REQUEST(xXFixesQueryVersionReq);
REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);
memset(&rep, 0, sizeof(xXFixesQueryVersionReply));
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
if (version_compare(stuff->majorVersion, stuff->minorVersion,
SERVER_XFIXES_MAJOR_VERSION, SERVER_XFIXES_MAJOR_VERSION) < 0)
{
rep.majorVersion = stuff->majorVersion;
rep.minorVersion = stuff->minorVersion;
} else {
rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
rep.minorVersion = SERVER_XFIXES_MINOR_VERSION;
}
pXFixesClient->major_version = rep.majorVersion;
pXFixesClient->minor_version = rep.minorVersion;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *)&rep);
return Success;
}
int test_version(const unsigned int version1, const unsigned int version2, const unsigned int operator)
{
const int version_result = version_compare(version1, version2);
switch(operator) {
case (VER_ANY):
return(TRUE);
case (VER_EQUAL):
if (version_result == 0) {
return(TRUE);
}
break;
case (VER_LESS):
if (version_result < 0) {
return(TRUE);
}
break;
case (VER_LESS_EQUAL):
if (version_result <= 0) {
return(TRUE);
}
break;
case (VER_MORE):
if (version_result > 0) {
return(TRUE);
}
break;
case (VER_MORE_EQUAL):
if (version_result >= 0) {
return(TRUE);
}
break;
}
return(FALSE);
}
static int
ProcRRQueryVersion(ClientPtr client)
{
xRRQueryVersionReply rep;
REQUEST(xRRQueryVersionReq);
rrClientPriv(client);
REQUEST_SIZE_MATCH(xRRQueryVersionReq);
pRRClient->major_version = stuff->majorVersion;
pRRClient->minor_version = stuff->minorVersion;
memset(&rep, 0, sizeof(rep));
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.length = 0;
if (version_compare(stuff->majorVersion, stuff->minorVersion,
SERVER_RANDR_MAJOR_VERSION,
SERVER_RANDR_MINOR_VERSION) < 0) {
rep.majorVersion = stuff->majorVersion;
rep.minorVersion = stuff->minorVersion;
}
else {
rep.majorVersion = SERVER_RANDR_MAJOR_VERSION;
rep.minorVersion = SERVER_RANDR_MINOR_VERSION;
}
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xRRQueryVersionReply), &rep);
return Success;
}
Bool
RRClientKnowsRates(ClientPtr pClient)
{
rrClientPriv(pClient);
return version_compare(pRRClient->major_version, pRRClient->minor_version,
1, 1) >= 0;
}
static int version_compare(const char *v1, const char *v2){
char n1[16];
char n2[16];
int ret;
if (*v1=='\0' && *v2=='\0') return 0;
v1+=copytilldot(n1,v1);
v2+=copytilldot(n2,v2);
ms_message("Comparing %s <> %s",n1,n2);
ret=strcmp(n1,n2);
if (ret==0) return version_compare(v1,v2);
else return ret;
}
static void update_check_result_cb(SoupSession *session,
SoupMessage *msg, gpointer user_data)
{
gint type = GPOINTER_TO_INT(user_data);
/* Checking whether we did get a valid (200) result */
if (msg->status_code == 200)
{
const gchar *remote_version = msg->response_body->data;
if (version_compare(remote_version) == TRUE)
{
gchar *update_msg = g_strdup_printf(
_("There is a more recent version of Geany available: %s"),
remote_version);
dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s", update_msg);
g_message("%s", update_msg);
g_free(update_msg);
}
else
{
const gchar *no_update_msg = _("No newer Geany version available.");
if (type == UPDATECHECK_MANUAL)
{
dialogs_show_msgbox(GTK_MESSAGE_INFO, "%s", no_update_msg);
}
else
{
msgwin_status_add("%s", no_update_msg);
}
g_message("%s", no_update_msg);
}
}
else
{
gchar *error_message = g_strdup_printf(
_("Unable to perform version check.\nError code: %d \nError message: »%s«"),
msg->status_code, msg->reason_phrase);
if (type == UPDATECHECK_MANUAL)
{
dialogs_show_msgbox(GTK_MESSAGE_ERROR, "%s", error_message);
}
else
{
msgwin_status_add("%s", error_message);
}
g_warning("Connection error: Code: %d; Message: %s", msg->status_code, msg->reason_phrase);
g_free(error_message);
}
}
static void *check_for_new_version(void *d){
const char *version_url=(const char *)d;
char version[256];
if (linphone_gtk_get_new_version(version_url,version,sizeof(version))==0){
if (version_compare(version,LINPHONE_VERSION)>0){
const char *download_site=linphone_gtk_get_ui_config("download_site",NULL);
if (download_site) {
gdk_threads_enter();
g_idle_add((GSourceFunc)popup_new_version,(gpointer)download_site);
gdk_threads_leave();
}
}else{
if (linphone_gtk_get_ui_config_int("update_check_menu",0)){
gdk_threads_enter();
g_idle_add((GSourceFunc)popup_version_ok,NULL);
gdk_threads_leave();
}
}
}
return NULL;
}
/**
* Function that assembles a default VCS info/version string from LAL and LALapps
* Also checks LAL header<>library version consistency and returns NULL on error.
*
* The VCS version string is allocated here and must be freed by caller.
*/
char *
XLALGetVersionString( int level )
{
char lal_info[1024];
#ifdef HAVE_LIBLALFRAME
char lalframe_info[1024];
#endif
#ifdef HAVE_LIBLALMETAIO
char lalmetaio_info[1024];
#endif
#ifdef HAVE_LIBLALXML
char lalxml_info[1024];
#endif
#ifdef HAVE_LIBLALSIMULATION
char lalsimulation_info[1024];
#endif
#ifdef HAVE_LIBLALBURST
char lalburst_info[1024];
#endif
#ifdef HAVE_LIBLALINSPIRAL
char lalinspiral_info[1024];
#endif
#ifdef HAVE_LIBLALPULSAR
char lalpulsar_info[1024];
#endif
#ifdef HAVE_LIBLALINFERENCE
char lalinference_info[1024];
#endif
#ifdef HAVE_LIBLALSTOCHASTIC
char lalstochastic_info[1024];
#endif
char lalapps_info[2048];
char *ret;
const char delim[] = ":";
char *tree_status, *orig_tree_status;
if ((LAL_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lal version consistency */
if (version_compare(__func__, &lalVCSInfoHeader, &lalVCSInfo))
exit(1);
}
#ifdef HAVE_LIBLALFRAME
if ((LALFRAME_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lalframe version consistency */
if (version_compare(__func__, &lalFrameVCSInfoHeader, &lalFrameVCSInfo))
exit(1);
}
#endif
#ifdef HAVE_LIBLALMETAIO
if ((LALMETAIO_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lalmetaio version consistency */
if (version_compare(__func__, &lalMetaIOVCSInfoHeader, &lalMetaIOVCSInfo))
exit(1);
}
#endif
#ifdef HAVE_LIBLALSIMULATION
if ((LALSIMULATION_VERSION_DEVEL != 0) || (LALSIMULATION_VERSION_DEVEL != 0))
{
/* check lalsimulaton version consistency */
if (version_compare(__func__, &lalSimulationVCSInfoHeader, &lalSimulationVCSInfo))
exit(1);
}
#endif
#ifdef HAVE_LIBLALXML
if ((LALXML_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lalxml version consistency */
if (version_compare(__func__, &lalXMLVCSInfoHeader, &lalXMLVCSInfo))
exit(1);
}
#endif
#ifdef HAVE_LIBLALBURST
if ((LALBURST_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lalburst version consistency */
if (version_compare(__func__, &lalBurstVCSInfoHeader, &lalBurstVCSInfo))
exit(1);
}
#endif
#ifdef HAVE_LIBLALINSPIRAL
if ((LALINSPIRAL_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lalinspiral version consistency */
if (version_compare(__func__, &lalInspiralVCSInfoHeader, &lalInspiralVCSInfo))
exit(1);
}
#endif
#ifdef HAVE_LIBLALPULSAR
if ((LALPULSAR_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lalpulsar version consistency */
if (version_compare(__func__, &lalPulsarVCSInfoHeader, &lalPulsarVCSInfo))
exit(1);
}
#endif
#ifdef HAVE_LIBLALINFERENCE
if ((LALINFERENCE_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lalinference version consistency */
if (version_compare(__func__, &lalInferenceVCSInfoHeader, &lalInferenceVCSInfo))
exit(1);
}
#endif
#ifdef HAVE_LIBLALSTOCHASTIC
if ((LALSTOCHASTIC_VERSION_DEVEL != 0) || (LALAPPS_VERSION_DEVEL != 0))
{
/* check lalstochastic version consistency */
if (version_compare(__func__, &lalStochasticVCSInfoHeader, &lalStochasticVCSInfo))
exit(1);
}
#endif
switch(level)
{
case 0:
/* get lal info */
tree_status = orig_tree_status = XLALStringDuplicate(lalVCSInfo.vcsStatus);
snprintf(lal_info, sizeof(lal_info),
"%%%% LAL: %s (%s %s)\n", lalVCSInfo.version, \
strtok(tree_status, delim), lalVCSInfo.vcsId);
XLALFree(orig_tree_status);
#ifdef HAVE_LIBLALFRAME
/* get lalframe info */
tree_status = orig_tree_status = XLALStringDuplicate(lalFrameVCSInfo.vcsStatus);
snprintf(lalframe_info, sizeof(lalframe_info),
"%%%% LALFrame: %s (%s %s)\n", lalFrameVCSInfo.version, \
strtok(tree_status, delim), lalFrameVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
#ifdef HAVE_LIBLALMETAIO
/* get lalmetaio info */
tree_status = orig_tree_status = XLALStringDuplicate(lalMetaIOVCSInfo.vcsStatus);
snprintf(lalmetaio_info, sizeof(lalmetaio_info),
"%%%% LALMetaIO: %s (%s %s)\n", lalMetaIOVCSInfo.version, \
strtok(tree_status, delim), lalMetaIOVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
#ifdef HAVE_LIBLALXML
/* get lalxml info */
tree_status = orig_tree_status = XLALStringDuplicate(lalXMLVCSInfo.vcsStatus);
snprintf(lalxml_info, sizeof(lalxml_info),
"%%%% LALXML: %s (%s %s)\n", lalXMLVCSInfo.version, \
strtok(tree_status, delim), lalXMLVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
#ifdef HAVE_LIBLALSIMULATION
/* get lalsimulation info */
tree_status = orig_tree_status = XLALStringDuplicate(lalSimulationVCSInfo.vcsStatus);
snprintf(lalsimulation_info, sizeof(lalsimulation_info),
"%%%% LALSimulation: %s (%s %s)\n", lalSimulationVCSInfo.version, \
strtok(tree_status, delim), lalSimulationVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
#ifdef HAVE_LIBLALBURST
/* get lalburst info */
tree_status = orig_tree_status = XLALStringDuplicate(lalBurstVCSInfo.vcsStatus);
snprintf(lalburst_info, sizeof(lalburst_info),
"%%%% LALBurst: %s (%s %s)\n", lalBurstVCSInfo.version, \
strtok(tree_status, delim), lalBurstVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
#ifdef HAVE_LIBLALINSPIRAL
/* get lalinspiral info */
tree_status = orig_tree_status = XLALStringDuplicate(lalInspiralVCSInfo.vcsStatus);
snprintf(lalinspiral_info, sizeof(lalinspiral_info),
"%%%% LALInspiral: %s (%s %s)\n", lalInspiralVCSInfo.version, \
strtok(tree_status, delim), lalInspiralVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
#ifdef HAVE_LIBLALPULSAR
/* get lalpulsar info */
tree_status = orig_tree_status = XLALStringDuplicate(lalPulsarVCSInfo.vcsStatus);
snprintf(lalpulsar_info, sizeof(lalpulsar_info),
"%%%% LALPulsar: %s (%s %s)\n", lalPulsarVCSInfo.version, \
strtok(tree_status, delim), lalPulsarVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
#ifdef HAVE_LIBLALINFERENCE
/* get lalinference info */
tree_status = orig_tree_status = XLALStringDuplicate(lalInferenceVCSInfo.vcsStatus);
snprintf(lalinference_info, sizeof(lalinference_info),
"%%%% LALInference: %s (%s %s)\n", lalInferenceVCSInfo.version, \
strtok(tree_status, delim), lalInferenceVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
#ifdef HAVE_LIBLALSTOCHASTIC
/* get lalstochastic info */
tree_status = orig_tree_status = XLALStringDuplicate(lalStochasticVCSInfo.vcsStatus);
snprintf(lalstochastic_info, sizeof(lalstochastic_info),
"%%%% LALStochastic: %s (%s %s)\n", lalStochasticVCSInfo.version, \
strtok(tree_status, delim), lalStochasticVCSInfo.vcsId);
XLALFree(orig_tree_status);
#endif
/* get lalapps info */
tree_status = orig_tree_status = XLALStringDuplicate(lalAppsVCSInfo.vcsStatus);
snprintf(lalapps_info, sizeof(lalapps_info),
"%%%% LALApps: %s (%s %s)\n", lalAppsVCSInfo.version, \
strtok(tree_status, delim), lalAppsVCSInfo.vcsId);
XLALFree(orig_tree_status);
break;
default:
/* get lal info */
snprintf( lal_info, sizeof(lal_info),
"%%%% LAL-Version: %s\n"
"%%%% LAL-Id: %s\n"
"%%%% LAL-Date: %s\n"
"%%%% LAL-Branch: %s\n"
"%%%% LAL-Tag: %s\n"
"%%%% LAL-Status: %s\n"
"%%%% LAL-Configure Date: %s\n"
"%%%% LAL-Configure Arguments: %s\n",
lalVCSInfo.version,
lalVCSInfo.vcsId,
lalVCSInfo.vcsDate,
lalVCSInfo.vcsBranch,
lalVCSInfo.vcsTag,
lalVCSInfo.vcsStatus,
lalConfigureDate ,
lalConfigureArgs );
#ifdef HAVE_LIBLALFRAME
/* get lalframe info */
snprintf( lalframe_info, sizeof(lalframe_info),
"%%%% LALFrame-Version: %s\n"
"%%%% LALFrame-Id: %s\n"
"%%%% LALFrame-Date: %s\n"
"%%%% LALFrame-Branch: %s\n"
"%%%% LALFrame-Tag: %s\n"
"%%%% LALFrame-Status: %s\n"
"%%%% LALFrame-Configure Date: %s\n"
"%%%% LALApps-Configure Arguments: %s\n",
lalFrameVCSInfo.version,
lalFrameVCSInfo.vcsId,
lalFrameVCSInfo.vcsDate,
lalFrameVCSInfo.vcsBranch,
lalFrameVCSInfo.vcsTag,
lalFrameVCSInfo.vcsStatus,
lalFrameConfigureDate ,
lalFrameConfigureArgs );
#endif
#ifdef HAVE_LIBLALMETAIO
/* get lalmetaio info */
snprintf( lalmetaio_info, sizeof(lalmetaio_info),
"%%%% LALMetaIO-Version: %s\n"
"%%%% LALMetaIO-Id: %s\n"
"%%%% LALMetaIO-Date: %s\n"
"%%%% LALMetaIO-Branch: %s\n"
"%%%% LALMetaIO-Tag: %s\n"
"%%%% LALMetaIO-Status: %s\n"
"%%%% LALMetaIO-Configure Date: %s\n"
"%%%% LALMetaIO-Configure Arguments: %s\n",
lalMetaIOVCSInfo.version,
lalMetaIOVCSInfo.vcsId,
lalMetaIOVCSInfo.vcsDate,
lalMetaIOVCSInfo.vcsBranch,
lalMetaIOVCSInfo.vcsTag,
lalMetaIOVCSInfo.vcsStatus,
lalMetaIOConfigureDate ,
lalMetaIOConfigureArgs );
#endif
#ifdef HAVE_LIBLALXML
/* get lalxml info */
snprintf( lalxml_info, sizeof(lalxml_info),
"%%%% LALXML-Version: %s\n"
"%%%% LALXML-Id: %s\n"
"%%%% LALXML-Date: %s\n"
"%%%% LALXML-Branch: %s\n"
"%%%% LALXML-Tag: %s\n"
"%%%% LALXML-Status: %s\n"
"%%%% LALXML-Configure Date: %s\n"
"%%%% LALXML-Configure Arguments: %s\n",
lalXMLVCSInfo.version,
lalXMLVCSInfo.vcsId,
lalXMLVCSInfo.vcsDate,
lalXMLVCSInfo.vcsBranch,
lalXMLVCSInfo.vcsTag,
lalXMLVCSInfo.vcsStatus,
lalXMLConfigureDate ,
lalXMLConfigureArgs );
#endif
#ifdef HAVE_LIBLALSIMULATION
/* get lalsimulation info */
snprintf( lalsimulation_info, sizeof(lalsimulation_info),
"%%%% LALSimulation-Version: %s\n"
"%%%% LALSimulation-Id: %s\n"
"%%%% LALSimulation-Date: %s\n"
"%%%% LALSimulation-Branch: %s\n"
"%%%% LALSimulation-Tag: %s\n"
"%%%% LALSimulation-Status: %s\n"
"%%%% LALSimulation-Configure Date: %s\n"
"%%%% LALSimulation-Configure Arguments: %s\n",
lalSimulationVCSInfo.version,
lalSimulationVCSInfo.vcsId,
lalSimulationVCSInfo.vcsDate,
lalSimulationVCSInfo.vcsBranch,
lalSimulationVCSInfo.vcsTag,
lalSimulationVCSInfo.vcsStatus,
lalSimulationConfigureDate ,
lalSimulationConfigureArgs );
#endif
#ifdef HAVE_LIBLALBURST
/* get lalburst info */
snprintf( lalburst_info, sizeof(lalburst_info),
"%%%% LALBurst-Version: %s\n"
"%%%% LALBurst-Id: %s\n"
"%%%% LALBurst-Date: %s\n"
"%%%% LALBurst-Branch: %s\n"
"%%%% LALBurst-Tag: %s\n"
"%%%% LALBurst-Status: %s\n"
"%%%% LALBurst-Configure Date: %s\n"
"%%%% LALBurst-Configure Arguments: %s\n",
lalBurstVCSInfo.version,
lalBurstVCSInfo.vcsId,
lalBurstVCSInfo.vcsDate,
lalBurstVCSInfo.vcsBranch,
lalBurstVCSInfo.vcsTag,
lalBurstVCSInfo.vcsStatus,
lalBurstConfigureDate ,
lalBurstConfigureArgs );
#endif
#ifdef HAVE_LIBLALINSPIRAL
/* get lalinspiral info */
snprintf( lalinspiral_info, sizeof(lalinspiral_info),
"%%%% LALInspiral-Version: %s\n"
"%%%% LALInspiral-Id: %s\n"
"%%%% LALInspiral-Date: %s\n"
"%%%% LALInspiral-Branch: %s\n"
"%%%% LALInspiral-Tag: %s\n"
"%%%% LALInspiral-Status: %s\n"
"%%%% LALInspiral-Configure Date: %s\n"
"%%%% LALInspiral-Configure Arguments: %s\n",
lalInspiralVCSInfo.version,
lalInspiralVCSInfo.vcsId,
lalInspiralVCSInfo.vcsDate,
lalInspiralVCSInfo.vcsBranch,
lalInspiralVCSInfo.vcsTag,
lalInspiralVCSInfo.vcsStatus,
lalInspiralConfigureDate ,
lalInspiralConfigureArgs );
#endif
#ifdef HAVE_LIBLALPULSAR
/* get lalpulsar info */
snprintf( lalpulsar_info, sizeof(lalpulsar_info),
"%%%% LALPulsar-Version: %s\n"
"%%%% LALPulsar-Id: %s\n"
"%%%% LALPulsar-Date: %s\n"
"%%%% LALPulsar-Branch: %s\n"
"%%%% LALPulsar-Tag: %s\n"
"%%%% LALPulsar-Status: %s\n"
"%%%% LALPulsar-Configure Date: %s\n"
"%%%% LALPulsar-Configure Arguments: %s\n",
lalPulsarVCSInfo.version,
lalPulsarVCSInfo.vcsId,
lalPulsarVCSInfo.vcsDate,
lalPulsarVCSInfo.vcsBranch,
lalPulsarVCSInfo.vcsTag,
lalPulsarVCSInfo.vcsStatus,
lalPulsarConfigureDate ,
lalPulsarConfigureArgs );
#endif
#ifdef HAVE_LIBLALINFERENCE
/* get lalinference info */
snprintf( lalinference_info, sizeof(lalinference_info),
"%%%% LALInference-Version: %s\n"
"%%%% LALInference-Id: %s\n"
"%%%% LALInference-Date: %s\n"
"%%%% LALInference-Branch: %s\n"
"%%%% LALInference-Tag: %s\n"
"%%%% LALInference-Status: %s\n"
"%%%% LALInference-Configure Date: %s\n"
"%%%% LALInference-Configure Arguments: %s\n",
lalInferenceVCSInfo.version,
lalInferenceVCSInfo.vcsId,
lalInferenceVCSInfo.vcsDate,
lalInferenceVCSInfo.vcsBranch,
lalInferenceVCSInfo.vcsTag,
lalInferenceVCSInfo.vcsStatus,
lalInferenceConfigureDate ,
lalInferenceConfigureArgs );
#endif
#ifdef HAVE_LIBLALSTOCHASTIC
/* get lalstochastic info */
snprintf( lalstochastic_info, sizeof(lalstochastic_info),
"%%%% LALStochastic-Version: %s\n"
"%%%% LALStochastic-Id: %s\n"
"%%%% LALStochastic-Date: %s\n"
"%%%% LALStochastic-Branch: %s\n"
"%%%% LALStochastic-Tag: %s\n"
"%%%% LALStochastic-Status: %s\n"
"%%%% LALStochastic-Configure Date: %s\n"
"%%%% LALStochastic-Configure Arguments: %s\n",
lalStochasticVCSInfo.version,
lalStochasticVCSInfo.vcsId,
lalStochasticVCSInfo.vcsDate,
lalStochasticVCSInfo.vcsBranch,
lalStochasticVCSInfo.vcsTag,
lalStochasticVCSInfo.vcsStatus,
lalStochasticConfigureDate ,
lalStochasticConfigureArgs );
#endif
/* add lalapps info */
snprintf( lalapps_info, sizeof(lalapps_info),
"%%%% LALApps-Version: %s\n"
"%%%% LALApps-Id: %s\n"
"%%%% LALApps-Date: %s\n"
"%%%% LALApps-Branch: %s\n"
"%%%% LALApps-Tag: %s\n"
"%%%% LALApps-Status: %s\n"
"%%%% LALApps-Configure Date: %s\n"
"%%%% LALApps-Configure Arguments: %s\n",
lalAppsVCSInfo.version,
lalAppsVCSInfo.vcsId,
lalAppsVCSInfo.vcsDate,
lalAppsVCSInfo.vcsBranch,
lalAppsVCSInfo.vcsTag,
lalAppsVCSInfo.vcsStatus,
lalAppsConfigureDate ,
lalAppsConfigureArgs );
break;
}
size_t len = strlen(lal_info) + strlen(lalapps_info) + 1;
#ifdef HAVE_LIBLALFRAME
len += strlen(lalframe_info);
#endif
#ifdef HAVE_LIBLALMETAIO
len += strlen(lalmetaio_info);
#endif
#ifdef HAVE_LIBLALXML
len += strlen(lalxml_info);
#endif
#ifdef HAVE_LIBLALSIMULATION
len += strlen(lalsimulation_info);
#endif
#ifdef HAVE_LIBLALBURST
len += strlen(lalburst_info);
#endif
#ifdef HAVE_LIBLALINSPIRAL
len += strlen(lalinspiral_info);
#endif
#ifdef HAVE_LIBLALPULSAR
len += strlen(lalpulsar_info);
#endif
#ifdef HAVE_LIBLALINFERENCE
len += strlen(lalinference_info);
#endif
#ifdef HAVE_LIBLALSTOCHASTIC
len += strlen(lalstochastic_info);
#endif
if ( (ret = XLALMalloc ( len )) == NULL ) {
XLALPrintError ("%s: Failed to XLALMalloc(%zu)\n", __func__, len );
XLAL_ERROR_NULL ( XLAL_ENOMEM );
}
strcpy ( ret, lal_info );
#ifdef HAVE_LIBLALFRAME
strcat ( ret, lalframe_info );
#endif
#ifdef HAVE_LIBLALMETAIO
strcat ( ret, lalmetaio_info );
#endif
#ifdef HAVE_LIBLALXML
strcat ( ret, lalxml_info );
#endif
#ifdef HAVE_LIBLALSIMULATION
strcat ( ret, lalsimulation_info );
#endif
#ifdef HAVE_LIBLALBURST
strcat ( ret, lalburst_info );
#endif
#ifdef HAVE_LIBLALINSPIRAL
strcat ( ret, lalinspiral_info );
#endif
#ifdef HAVE_LIBLALPULSAR
strcat ( ret, lalpulsar_info );
#endif
#ifdef HAVE_LIBLALINFERENCE
strcat ( ret, lalinference_info );
#endif
#ifdef HAVE_LIBLALSTOCHASTIC
strcat ( ret, lalstochastic_info );
#endif
strcat ( ret, lalapps_info );
return ( ret );
} /* XLALGetVersionString() */
static int version_compare_qsort (const void * AA, const void * BB)
{
return version_compare (* (version_t * const *) AA,
* (version_t * const *) BB);
}
int
ProcXIAllowEvents(ClientPtr client)
{
TimeStamp time;
DeviceIntPtr dev;
int ret = Success;
XIClientPtr xi_client;
Bool have_xi22 = FALSE;
REQUEST(xXI2_2AllowEventsReq);
xi_client = dixLookupPrivate(&client->devPrivates, XIClientPrivateKey);
if (version_compare(xi_client->major_version,
xi_client->minor_version, 2, 2) >= 0) {
REQUEST_AT_LEAST_SIZE(xXI2_2AllowEventsReq);
have_xi22 = TRUE;
}
else {
REQUEST_SIZE_MATCH(xXIAllowEventsReq);
}
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
if (ret != Success)
return ret;
time = ClientTimeToServerTime(stuff->time);
switch (stuff->mode) {
case XIReplayDevice:
AllowSome(client, time, dev, NOT_GRABBED);
break;
case XISyncDevice:
AllowSome(client, time, dev, FREEZE_NEXT_EVENT);
break;
case XIAsyncDevice:
AllowSome(client, time, dev, THAWED);
break;
case XIAsyncPairedDevice:
if (IsMaster(dev))
AllowSome(client, time, dev, THAW_OTHERS);
break;
case XISyncPair:
if (IsMaster(dev))
AllowSome(client, time, dev, FREEZE_BOTH_NEXT_EVENT);
break;
case XIAsyncPair:
if (IsMaster(dev))
AllowSome(client, time, dev, THAWED_BOTH);
break;
case XIRejectTouch:
case XIAcceptTouch:
{
int rc;
WindowPtr win;
if (!have_xi22)
return BadValue;
rc = dixLookupWindow(&win, stuff->grab_window, client, DixReadAccess);
if (rc != Success)
return rc;
ret = TouchAcceptReject(client, dev, stuff->mode, stuff->touchid,
stuff->grab_window, &client->errorValue);
}
break;
default:
client->errorValue = stuff->mode;
ret = BadValue;
}
return ret;
}
int
ProcXIQueryPointer(ClientPtr client)
{
int rc;
xXIQueryPointerReply rep;
DeviceIntPtr pDev, kbd;
WindowPtr pWin, t;
SpritePtr pSprite;
XkbStatePtr state;
char *buttons = NULL;
int buttons_size = 0; /* size of buttons array */
XIClientPtr xi_client;
Bool have_xi22 = FALSE;
REQUEST(xXIQueryPointerReq);
REQUEST_SIZE_MATCH(xXIQueryPointerReq);
/* Check if client is compliant with XInput 2.2 or later. Earlier clients
* do not know about touches, so we must report emulated button presses. 2.2
* and later clients are aware of touches, so we don't include emulated
* button presses in the reply. */
xi_client = dixLookupPrivate(&client->devPrivates, XIClientPrivateKey);
if (version_compare(xi_client->major_version,
xi_client->minor_version, 2, 2) >= 0)
have_xi22 = TRUE;
rc = dixLookupDevice(&pDev, stuff->deviceid, client, DixReadAccess);
if (rc != Success) {
client->errorValue = stuff->deviceid;
return rc;
}
if (pDev->valuator == NULL || IsKeyboardDevice(pDev) || (!IsMaster(pDev) && !IsFloating(pDev))) { /* no attached devices */
client->errorValue = stuff->deviceid;
return BadDevice;
}
rc = dixLookupWindow(&pWin, stuff->win, client, DixGetAttrAccess);
if (rc != Success) {
client->errorValue = stuff->win;
return rc;
}
if (pDev->valuator->motionHintWindow)
MaybeStopHint(pDev, client);
if (IsMaster(pDev))
kbd = GetMaster(pDev, MASTER_KEYBOARD);
else
kbd = (pDev->key) ? pDev : NULL;
pSprite = pDev->spriteInfo->sprite;
rep = (xXIQueryPointerReply) {
.repType = X_Reply,
.RepType = X_XIQueryPointer,
.sequenceNumber = client->sequence,
.length = 6,
.root = (GetCurrentRootWindow(pDev))->drawable.id,
.root_x = double_to_fp1616(pSprite->hot.x),
.root_y = double_to_fp1616(pSprite->hot.y),
.child = None
};
if (kbd) {
state = &kbd->key->xkbInfo->state;
rep.mods.base_mods = state->base_mods;
rep.mods.latched_mods = state->latched_mods;
rep.mods.locked_mods = state->locked_mods;
rep.group.base_group = state->base_group;
rep.group.latched_group = state->latched_group;
rep.group.locked_group = state->locked_group;
}
if (pDev->button) {
int i;
rep.buttons_len =
bytes_to_int32(bits_to_bytes(pDev->button->numButtons));
rep.length += rep.buttons_len;
buttons = calloc(rep.buttons_len, 4);
if (!buttons)
return BadAlloc;
buttons_size = rep.buttons_len * 4;
for (i = 1; i < pDev->button->numButtons; i++)
if (BitIsOn(pDev->button->down, i))
SetBit(buttons, pDev->button->map[i]);
if (!have_xi22 && pDev->touch && pDev->touch->buttonsDown > 0)
SetBit(buttons, pDev->button->map[1]);
}
else
rep.buttons_len = 0;
if (pSprite->hot.pScreen == pWin->drawable.pScreen) {
rep.same_screen = xTrue;
rep.win_x = double_to_fp1616(pSprite->hot.x - pWin->drawable.x);
rep.win_y = double_to_fp1616(pSprite->hot.y - pWin->drawable.y);
for (t = pSprite->win; t; t = t->parent)
if (t->parent == pWin) {
rep.child = t->drawable.id;
break;
}
}
else {
rep.same_screen = xFalse;
rep.win_x = 0;
rep.win_y = 0;
}
#ifdef PANORAMIX
if (!noPanoramiXExtension) {
rep.root_x += double_to_fp1616(screenInfo.screens[0]->x);
rep.root_y += double_to_fp1616(screenInfo.screens[0]->y);
if (stuff->win == rep.root) {
rep.win_x += double_to_fp1616(screenInfo.screens[0]->x);
rep.win_y += double_to_fp1616(screenInfo.screens[0]->y);
}
}
#endif
WriteReplyToClient(client, sizeof(xXIQueryPointerReply), &rep);
if (buttons)
WriteToClient(client, buttons_size, buttons);
free(buttons);
return Success;
}
/***********************************************************************
*
* This procedure writes the reply for the XIQueryPointer function,
* if the client and server have a different byte ordering.
*
*/
void
SRepXIQueryPointer(ClientPtr client, int size, xXIQueryPointerReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->root);
swapl(&rep->child);
swapl(&rep->root_x);
swapl(&rep->root_y);
swapl(&rep->win_x);
swapl(&rep->win_y);
swaps(&rep->buttons_len);
WriteToClient(client, size, rep);
}
static int
ProcXFixesQueryVersion(ClientPtr client)
{
XFixesClientPtr pXFixesClient = GetXFixesClient(client);
xXFixesQueryVersionReply rep = {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = 0
};
REQUEST(xXFixesQueryVersionReq);
REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);
if (version_compare(stuff->majorVersion, stuff->minorVersion,
SERVER_XFIXES_MAJOR_VERSION,
SERVER_XFIXES_MINOR_VERSION) < 0) {
rep.majorVersion = stuff->majorVersion;
rep.minorVersion = stuff->minorVersion;
}
else {
rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
rep.minorVersion = SERVER_XFIXES_MINOR_VERSION;
}
pXFixesClient->major_version = rep.majorVersion;
pXFixesClient->minor_version = rep.minorVersion;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xXFixesQueryVersionReply), &rep);
return Success;
}
/* Major version controls available requests */
static const int version_requests[] = {
X_XFixesQueryVersion, /* before client sends QueryVersion */
X_XFixesGetCursorImage, /* Version 1 */
X_XFixesChangeCursorByName, /* Version 2 */
X_XFixesExpandRegion, /* Version 3 */
X_XFixesShowCursor, /* Version 4 */
X_XFixesDestroyPointerBarrier, /* Version 5 */
};
#define NUM_VERSION_REQUESTS (sizeof (version_requests) / sizeof (version_requests[0]))
int (*ProcXFixesVector[XFixesNumberRequests]) (ClientPtr) = {
/*************** Version 1 ******************/
ProcXFixesQueryVersion,
ProcXFixesChangeSaveSet,
ProcXFixesSelectSelectionInput,
ProcXFixesSelectCursorInput, ProcXFixesGetCursorImage,
/*************** Version 2 ******************/
ProcXFixesCreateRegion,
ProcXFixesCreateRegionFromBitmap,
ProcXFixesCreateRegionFromWindow,
ProcXFixesCreateRegionFromGC,
ProcXFixesCreateRegionFromPicture,
ProcXFixesDestroyRegion,
ProcXFixesSetRegion,
ProcXFixesCopyRegion,
ProcXFixesCombineRegion,
ProcXFixesCombineRegion,
ProcXFixesCombineRegion,
ProcXFixesInvertRegion,
ProcXFixesTranslateRegion,
ProcXFixesRegionExtents,
ProcXFixesFetchRegion,
ProcXFixesSetGCClipRegion,
ProcXFixesSetWindowShapeRegion,
ProcXFixesSetPictureClipRegion,
ProcXFixesSetCursorName,
ProcXFixesGetCursorName,
ProcXFixesGetCursorImageAndName,
ProcXFixesChangeCursor, ProcXFixesChangeCursorByName,
/*************** Version 3 ******************/
ProcXFixesExpandRegion,
/*************** Version 4 ****************/
ProcXFixesHideCursor, ProcXFixesShowCursor,
/*************** Version 5 ****************/
ProcXFixesCreatePointerBarrier, ProcXFixesDestroyPointerBarrier,};
static int
ProcXFixesDispatch(ClientPtr client)
{
REQUEST(xXFixesReq);
XFixesClientPtr pXFixesClient = GetXFixesClient(client);
if (pXFixesClient->major_version >= NUM_VERSION_REQUESTS)
return BadRequest;
if (stuff->xfixesReqType > version_requests[pXFixesClient->major_version])
return BadRequest;
return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
}
