static void
test_list_ops(void **state)
{
char **list;
list = calloc(2, sizeof(char *));
assert_non_null(list);
list[0] = strdup("foo");
assert_non_null(list[0]);
assert_int_equal(null_string_array_size(list), 1);
free_string_list(list);
free_string_list(NULL);
assert_int_equal(null_string_array_size(NULL), 0);
}
/****************************************************************************
* Create a new alignment with any sequence that contains nothing but
* gap ('-') characters removed. Returns the new alignment. Does not
* change the old alignment.
* If there are no all-gap sequences, the returned alignment is the
* same object as the original alignment.
****************************************************************************/
static ALIGNMENT_T* remove_allgap_sequences(ALIGNMENT_T* alignment)
{
ALIGNMENT_T* new_alignment;
int i_aln;
int l_aln = get_num_aligned_sequences(alignment);
STRING_LIST_T* keeper_seqs = new_string_list();
// Identify the all-gap sequences.
for (i_aln=0; i_aln<l_aln; i_aln++) {
SEQ_T* sequence = get_alignment_sequence(i_aln, alignment);
int i_seq;
int l_seq = get_seq_length(sequence);
// Add sequence to keepers if it contains a non-gap.
for (i_seq=0; i_seq<l_seq; i_seq++) {
if (get_seq_char(i_seq, sequence) != '-') { // not gap?
add_string(get_seq_name(sequence), keeper_seqs); // non-gap: keeper
break;
}
}
}
// Remove any sequences not in keeper list.
if (get_num_strings(keeper_seqs) < l_aln) {
new_alignment = remove_alignment_seqs(keeper_seqs, alignment);
free_string_list(keeper_seqs);
} else {
new_alignment = alignment;
}
return(new_alignment);
} // remove_allgap_sequences
void append_string_to_args( char * sin ,
int argc , char * argv[] ,
int * new_argc , char *** new_argv )
{
int n_argc , ii , ntok=0 ;
char ** n_argv , ** stok=NULL ;
char * cpt , * sss ;
if( new_argc == NULL || new_argv == NULL ) return ; /* error */
if( sin == NULL || sin[0] == '\0' ){ *new_argv = NULL; return; } /* do nothing */
tokenize_string( sin , &ntok , &stok ) ;
if( stok == NULL || ntok < 1 ){ *new_argv = NULL; return; } /* do nothing */
/* copy input args to output */
if( argc > 0 ){
duplicate_string_list( argc , argv , &n_argv ) ;
n_argc = argc ;
} else { /* shouldn't happen */
n_argv = NULL ;
n_argc = 0 ;
}
/* append token list to output */
appendto_string_list( &n_argc , &n_argv , ntok , stok ) ;
free_string_list( ntok , stok ) ;
*new_argc = n_argc ; /* the results! */
*new_argv = n_argv ;
return ;
}
void free_kvpair(kvpair_t* pair)
{
if (pair) {
free_kvpair(pair->next);
free(pair->key);
free_string_list(pair->values);
free(pair);
}
}
/*******************************************************************************
* Free TRANSFAC motif structure
******************************************************************************/
void free_transfac_motif(void *motif) {
TRANSFAC_MOTIF_T *trans_motif = motif;
myfree(trans_motif->accession);
myfree(trans_motif->id);
myfree(trans_motif->name);
myfree(trans_motif->description);
myfree(trans_motif->consensus);
free_string_list(trans_motif->species_list);
free_matrix(trans_motif->counts);
myfree(trans_motif);
}
void
free_record_data(void *rdata)
{
struct record_data *r = rdata;
switch (r->type) {
case RECDB_INVALID: break;
case RECDB_QSTRING: free(r->d.qstring); break;
case RECDB_OBJECT: dict_delete(r->d.object); break;
case RECDB_STRING_LIST: free_string_list(r->d.slist); break;
}
free(r);
}
/**
* Free the list of qemu options.
*/
void
qemuopts_free (struct qemuopts *qopts)
{
size_t i;
for (i = 0; i < qopts->nr_options; ++i) {
free (qopts->options[i].flag);
free (qopts->options[i].value);
free_string_list (qopts->options[i].values);
}
free (qopts->options);
free (qopts->binary);
free (qopts);
}
/* Performs filename expansion on a list of strings. The list of strings is
* replaced with the list of expanded strings. 0 is returned on success; -1 is
* returned on read error in glob(). */
static int do_filename_expansion(struct list_head *string_list)
{
struct string *s, *tmp;
int ret = 0;
LIST_HEAD(new_list);
list_for_each_entry_safe(s, tmp, string_list, list)
ret |= string_do_filename_expansion(s, &new_list);
INIT_LIST_HEAD(string_list);
if (ret)
free_string_list(&new_list);
else
list_splice_tail(&new_list, string_list);
return ret;
}
static void free_syntax(struct syntax *syn)
{
int i;
for (i = 0; i < syn->states.count; i++)
free_state(syn->states.ptrs[i]);
free(syn->states.ptrs);
for (i = 0; i < syn->string_lists.count; i++)
free_string_list(syn->string_lists.ptrs[i]);
free(syn->string_lists.ptrs);
for (i = 0; i < syn->default_colors.count; i++)
free_strings(syn->default_colors.ptrs[i]);
free(syn->default_colors.ptrs);
free(syn->name);
free(syn);
}
static kvpair_t *grok_form(xmpp_stanza_t *fields)
{
kvpair_t *rv = NULL;
/* walk the field peers and grab their values and stuff */
while (fields) {
if (xmpp_stanza_is_tag(fields)) {
char* k = xmpp_stanza_get_attribute(fields, "var");
char **vals = get_specific_form_values(fields, k);
kvpair_t* thispair = mk_kvpair(k, vals);
free_string_list(vals);
thispair->next = rv;
rv = thispair;
}
fields = xmpp_stanza_get_next(fields);
}
return rv;
}
void prepend_string_to_args( char * sin ,
int argc , char * argv[] ,
int * new_argc , char *** new_argv )
{
int n_argc , ii , ntok=0 ;
char ** n_argv , ** stok=NULL ;
char * cpt , * sss ;
if( new_argc == NULL || new_argv == NULL ) return ; /* error */
if( sin == NULL || sin[0] == '\0' ){ *new_argv = NULL; return; } /* do nothing */
/*-- if no inputs after argv[0], prepend and append are identical --*/
if( argc < 2 ){
append_string_to_args( sin , argc , argv , new_argc , new_argv ) ;
return ;
}
/*-- OK, must do it my way --*/
tokenize_string( sin , &ntok , &stok ) ;
if( stok == NULL || ntok < 1 ){ *new_argv = NULL; return; } /* do nothing */
/* copy first input arg to output */
duplicate_string_list( 1 , argv , &n_argv ) ;
n_argc = 1 ;
/* append token list to output */
appendto_string_list( &n_argc , &n_argv , ntok , stok ) ;
free_string_list( ntok , stok ) ;
/* append rest of input args to output */
appendto_string_list( &n_argc , &n_argv , argc-1 , argv+1 ) ;
*new_argc = n_argc ; /* the results! */
*new_argv = n_argv ;
return ;
}
/*
* Returns a list of lines
*/
STRING_LIST *fread_file( char *filename ) {
FILE *fp=fopen( filename, "r" );
STRING_LIST *slist=NULL;
STRING_LIST *last=NULL;
if (fp == NULL) { OUTPUT("File not found: %s\n", filename); return NULL; }
while( !feof(fp) && !ferror(fp) )
{
STRING_LIST *snode = new_string_list( );
snode->str=fread_string_eol(fp);
if ( snode->str == NULL ) { free_string_list(snode); break; }
if ( last != NULL ) last->next = snode;
else slist=snode;
last=snode;
}
fclose(fp);
return slist;
}
static void new_alias (gpointer data, PurpleRequestFields *fields)
{
GtkTreeIter iter;
GList *aliases;
const char *alias;
alias = purple_request_fields_get_string (fields, "alias");
aliases = purple_prefs_get_string_list (
"/plugins/gtk/autoprofile/components/logstat/aliases");
aliases = g_list_append (aliases, strdup (alias));
purple_prefs_set_string_list (
"/plugins/gtk/autoprofile/components/logstat/aliases", aliases);
free_string_list (aliases);
gtk_list_store_insert (alias_list, &iter, 0);
gtk_list_store_set (alias_list, &iter,
0, alias, -1);
}
static void alias_delete (GtkButton *button, gpointer data)
{
GtkTreeSelection *selection;
GtkTreeIter iter;
char *alias;
GList *aliases, *aliases_start, *new_aliases;
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (alias_view));
if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
return;
gtk_tree_model_get (GTK_TREE_MODEL (alias_list), &iter,
0, &alias, -1);
gtk_list_store_remove (alias_list, &iter);
aliases = purple_prefs_get_string_list (
"/plugins/gtk/autoprofile/components/logstat/aliases");
aliases_start = aliases;
new_aliases = NULL;
while (aliases) {
if (strcmp ((char *)aliases->data, alias)) {
new_aliases = g_list_append (new_aliases, aliases->data);
}
aliases = aliases->next;
}
purple_prefs_set_string_list (
"/plugins/gtk/autoprofile/components/logstat/aliases", new_aliases);
free_string_list (aliases_start);
g_list_free (new_aliases);
free (alias);
}
BOOLEAN
CreateRpcBinding(
PVOID *phBinding,
RPC_BINDING_TYPE eBindingType,
PCWSTR pwszHostname,
PCWSTR pwszBinding,
PCREDENTIALS pCredentials
)
{
PCSTR pszNtlmsspAuth = "ntlmssp";
PCSTR pszSign = "sign";
PCSTR pszSeal = "seal";
BOOLEAN bRet = TRUE;
NTSTATUS ntStatus = STATUS_SUCCESS;
DWORD dwError = ERROR_SUCCESS;
unsigned32 rpcStatus = RPC_S_OK;
LSA_BINDING hBinding = NULL;
LW_PIO_CREDS pIoCreds = NULL;
PWSTR pwszBindingString = NULL;
size_t sBindingStringLen = 0;
PSTR pszBindingString = NULL;
PSTR *ppszOptions = NULL;
DWORD iOpt = 0;
DWORD i = 0;
DWORD dwNumValidOptions = 0;
unsigned32 AuthType = 0;
unsigned32 ProtectionLevel = 0;
SEC_WINNT_AUTH_IDENTITY *pNtlmSspAuthInfo = NULL;
PVOID pAuthInfo = NULL;
unsigned char *pszUuid = NULL;
unsigned char *pszProtSeq = NULL;
unsigned char *pszNetworkAddr = NULL;
unsigned char *pszEndpoint = NULL;
unsigned char *pszOptions = NULL;
PSTR pszHostname = NULL;
if (phBinding == NULL)
{
ntStatus = STATUS_INVALID_PARAMETER;
BAIL_ON_NT_STATUS(ntStatus);
}
if (pwszBinding)
{
dwError = LwAllocateWc16String(&pwszBindingString,
pwszBinding);
BAIL_ON_WIN_ERROR(dwError);
dwError = LwWc16sLen(pwszBindingString, &sBindingStringLen);
BAIL_ON_WIN_ERROR(dwError);
dwError = LwWc16sToMbs(pwszBindingString,
&pszBindingString);
BAIL_ON_WIN_ERROR(dwError);
ppszOptions = get_string_list(pszBindingString, ':');
if (ppszOptions == NULL)
{
ntStatus = STATUS_INVALID_PARAMETER;
BAIL_ON_NT_STATUS(ntStatus);
}
/*
* Find and identify valid options
*/
while (ppszOptions[iOpt])
{
if (!strcasecmp(pszNtlmsspAuth, ppszOptions[iOpt]))
{
AuthType = rpc_c_authn_winnt;
dwNumValidOptions++;
}
else if (!strcasecmp(pszSign, ppszOptions[iOpt]))
{
ProtectionLevel = rpc_c_authn_level_pkt_integrity;
dwNumValidOptions++;
}
else if (!strcasecmp(pszSeal, ppszOptions[iOpt]))
{
ProtectionLevel = rpc_c_authn_level_pkt_privacy;
dwNumValidOptions++;
}
iOpt++;
}
}
/*
* Cut off the options from the binding string so it can
* be passed to rpc routines
*/
if (dwNumValidOptions > 0)
{
i = sBindingStringLen;
while (dwNumValidOptions &&
pwszBindingString[--i])
{
if (pwszBindingString[i] == (WCHAR)':')
{
dwNumValidOptions--;
}
}
pwszBindingString[i] = (WCHAR)'\0';
pszBindingString[i] = '\0';
}
ntStatus = LwIoGetActiveCreds(NULL, &pIoCreds);
BAIL_ON_NT_STATUS(ntStatus);
if (pwszBindingString)
{
ntStatus = RpcInitBindingFromBindingString(
(handle_t*)&hBinding,
pwszBindingString,
pIoCreds);
}
else
{
switch (eBindingType)
{
case RPC_LSA_BINDING:
ntStatus = LsaInitBindingDefault(&hBinding,
pwszHostname,
pIoCreds);
break;
case RPC_SAMR_BINDING:
ntStatus = SamrInitBindingDefault(&hBinding,
pwszHostname,
pIoCreds);
break;
case RPC_NETLOGON_BINDING:
ntStatus = NetrInitBindingDefault(&hBinding,
pwszHostname,
pIoCreds);
break;
case RPC_DSSETUP_BINDING:
ntStatus = DsrInitBindingDefault(&hBinding,
pwszHostname,
pIoCreds);
break;
case RPC_WKSSVC_BINDING:
ntStatus = WkssInitBindingDefault(&hBinding,
pwszHostname,
pIoCreds);
break;
default:
ntStatus = STATUS_NOT_IMPLEMENTED;
break;
}
}
BAIL_ON_NT_STATUS(ntStatus);
switch (AuthType)
{
case rpc_c_authn_winnt:
dwError = LwAllocateMemory(sizeof(*pNtlmSspAuthInfo),
OUT_PPVOID(&pNtlmSspAuthInfo));
BAIL_ON_WIN_ERROR(dwError);
if (pCredentials->Ntlm.pwszDomain)
{
dwError = LwWc16sToMbs(pCredentials->Ntlm.pwszDomain,
&pNtlmSspAuthInfo->Domain);
BAIL_ON_WIN_ERROR(dwError);
pNtlmSspAuthInfo->DomainLength = strlen(pNtlmSspAuthInfo->Domain);
}
dwError = LwWc16sToMbs(pCredentials->Ntlm.pwszUsername,
&pNtlmSspAuthInfo->User);
BAIL_ON_WIN_ERROR(dwError);
pNtlmSspAuthInfo->UserLength = strlen(pNtlmSspAuthInfo->User);
dwError = LwWc16sToMbs(pCredentials->Ntlm.pwszPassword,
&pNtlmSspAuthInfo->Password);
BAIL_ON_WIN_ERROR(dwError);
pNtlmSspAuthInfo->PasswordLength = strlen(pNtlmSspAuthInfo->Password);
pAuthInfo = (PVOID)pNtlmSspAuthInfo;
break;
default:
pAuthInfo = NULL;
break;
}
if (pwszHostname)
{
dwError = LwWc16sToMbs(pwszHostname,
&pszHostname);
BAIL_ON_WIN_ERROR(dwError);
}
else
{
rpc_string_binding_parse((unsigned char*)pszBindingString,
&pszUuid,
&pszProtSeq,
&pszNetworkAddr,
&pszEndpoint,
&pszOptions,
&rpcStatus);
if (rpcStatus)
{
ntStatus = LwRpcStatusToNtStatus(rpcStatus);
BAIL_ON_NT_STATUS(ntStatus);
}
dwError = LwAllocateString((PSTR)pszNetworkAddr,
&pszHostname);
BAIL_ON_WIN_ERROR(dwError);
}
if (AuthType)
{
rpc_binding_set_auth_info(hBinding,
(unsigned char*)pszHostname,
ProtectionLevel,
AuthType,
(rpc_auth_identity_handle_t)pAuthInfo,
rpc_c_authz_name, /* authz_protocol */
&rpcStatus);
if (rpcStatus)
{
ntStatus = LwRpcStatusToNtStatus(rpcStatus);
BAIL_ON_NT_STATUS(ntStatus);
}
}
*phBinding = hBinding;
cleanup:
if (pIoCreds)
{
LwIoDeleteCreds(pIoCreds);
}
LW_SAFE_FREE_MEMORY(pwszBindingString);
LW_SAFE_FREE_MEMORY(pszBindingString);
LW_SAFE_FREE_MEMORY(pszHostname);
rpc_string_free(&pszUuid, &rpcStatus);
rpc_string_free(&pszProtSeq, &rpcStatus);
rpc_string_free(&pszNetworkAddr, &rpcStatus);
rpc_string_free(&pszEndpoint, &rpcStatus);
rpc_string_free(&pszOptions, &rpcStatus);
if (ppszOptions)
{
free_string_list(ppszOptions);
}
if (ntStatus == STATUS_SUCCESS &&
dwError != ERROR_SUCCESS)
{
ntStatus = LwWin32ErrorToNtStatus(dwError);
}
if (ntStatus != STATUS_SUCCESS)
{
bRet = FALSE;
}
return bRet;
error:
*phBinding = NULL;
bRet = FALSE;
goto cleanup;
}
/*************************************************************************
* Entry point for pmp_bf
*************************************************************************/
int main(int argc, char *argv[]) {
char* bg_filename = NULL;
char* motif_name = "motif"; // Use this motif name in the output.
STRING_LIST_T* selected_motifs = NULL;
double fg_rate = 1.0;
double bg_rate = 1.0;
double purine_pyrimidine = 1.0; // r
double transition_transversion = 0.5; // R
double pseudocount = 0.1;
GAP_SUPPORT_T gap_support = SKIP_GAPS;
MODEL_TYPE_T model_type = F81_MODEL;
BOOLEAN_T use_halpern_bruno = FALSE;
char* ustar_label = NULL; // TLB; create uniform star tree
int i;
program_name = "pmp_bf";
/**********************************************
* COMMAND LINE PROCESSING
**********************************************/
// Define command line options. (FIXME: Repeated code)
// FIXME: Note that if you add or remove options you
// must change n_options.
int n_options = 12;
cmdoption const pmp_options[] = {
{"hb", NO_VALUE},
{"ustar", REQUIRED_VALUE},
{"model", REQUIRED_VALUE},
{"pur-pyr", REQUIRED_VALUE},
{"transition-transversion", REQUIRED_VALUE},
{"bg", REQUIRED_VALUE},
{"fg", REQUIRED_VALUE},
{"motif", REQUIRED_VALUE},
{"motif-name", REQUIRED_VALUE},
{"bgfile", REQUIRED_VALUE},
{"pseudocount", REQUIRED_VALUE},
{"verbosity", REQUIRED_VALUE}
};
int option_index = 0;
// Define the usage message.
char usage[1000] = "";
strcat(usage, "USAGE: pmp [options] <tree file> <MEME file>\n");
strcat(usage, "\n");
strcat(usage, " Options:\n");
// Evolutionary model parameters.
strcat(usage, " --hb\n");
strcat(usage, " --model single|average|jc|k2|f81|f84|hky|tn");
strcat(usage, " (default=f81)\n");
strcat(usage, " --pur-pyr <float> (default=1.0)\n");
strcat(usage, " --transition-transversion <float> (default=0.5)\n");
strcat(usage, " --bg <float> (default=1.0)\n");
strcat(usage, " --fg <float> (default=1.0)\n");
// Motif parameters.
strcat(usage, " --motif <id> (default=all)\n");
strcat(usage, " --motif-name <string> (default from motif file)\n");
// Miscellaneous parameters
strcat(usage, " --bgfile <background> (default from motif file)\n");
strcat(usage, " --pseudocount <float> (default=0.1)\n");
strcat(usage, " --ustar <label>\n"); // TLB; create uniform star tree
strcat(usage, " --verbosity [1|2|3|4] (default 2)\n");
strcat(usage, "\n Prints the FP and FN rate at each of 10000 score values.\n");
strcat(usage, "\n Output format: [<motif_id> score <score> FPR <fpr> TPR <tpr>]+\n");
// Parse the command line.
if (simple_setopt(argc, argv, n_options, pmp_options) != NO_ERROR) {
die("Error processing command line options: option name too long.\n");
}
while (TRUE) {
int c = 0;
char* option_name = NULL;
char* option_value = NULL;
const char * message = NULL;
// Read the next option, and break if we're done.
c = simple_getopt(&option_name, &option_value, &option_index);
if (c == 0) {
break;
} else if (c < 0) {
(void) simple_getopterror(&message);
die("Error processing command line options (%s)\n", message);
}
if (strcmp(option_name, "model") == 0) {
if (strcmp(option_value, "jc") == 0) {
model_type = JC_MODEL;
} else if (strcmp(option_value, "k2") == 0) {
model_type = K2_MODEL;
} else if (strcmp(option_value, "f81") == 0) {
model_type = F81_MODEL;
} else if (strcmp(option_value, "f84") == 0) {
model_type = F84_MODEL;
} else if (strcmp(option_value, "hky") == 0) {
model_type = HKY_MODEL;
} else if (strcmp(option_value, "tn") == 0) {
model_type = TAMURA_NEI_MODEL;
} else if (strcmp(option_value, "single") == 0) {
model_type = SINGLE_MODEL;
} else if (strcmp(option_value, "average") == 0) {
model_type = AVERAGE_MODEL;
} else {
die("Unknown model: %s\n", option_value);
}
} else if (strcmp(option_name, "hb") == 0){
use_halpern_bruno = TRUE;
} else if (strcmp(option_name, "ustar") == 0){ // TLB; create uniform star tree
ustar_label = option_value;
} else if (strcmp(option_name, "pur-pyr") == 0){
purine_pyrimidine = atof(option_value);
} else if (strcmp(option_name, "transition-transversion") == 0){
transition_transversion = atof(option_value);
} else if (strcmp(option_name, "bg") == 0){
bg_rate = atof(option_value);
} else if (strcmp(option_name, "fg") == 0){
fg_rate = atof(option_value);
} else if (strcmp(option_name, "motif") == 0){
if (selected_motifs == NULL) {
selected_motifs = new_string_list();
}
add_string(option_value, selected_motifs);
} else if (strcmp(option_name, "motif-name") == 0){
motif_name = option_value;
} else if (strcmp(option_name, "bgfile") == 0){
bg_filename = option_value;
} else if (strcmp(option_name, "pseudocount") == 0){
pseudocount = atof(option_value);
} else if (strcmp(option_name, "verbosity") == 0){
verbosity = atoi(option_value);
}
}
// Must have tree and motif file names
if (argc != option_index + 2) {
fprintf(stderr, "%s", usage);
exit(EXIT_FAILURE);
}
/**********************************************
* Read the phylogenetic tree.
**********************************************/
char* tree_filename = NULL;
TREE_T* tree = NULL;
tree_filename = argv[option_index];
option_index++;
tree = read_tree_from_file(tree_filename);
// get the species names
STRING_LIST_T* alignment_species = make_leaf_list(tree);
char *root_label = get_label(tree); // in case target in center
if (strlen(root_label)>0) add_string(root_label, alignment_species);
//write_string_list(" ", alignment_species, stderr);
// TLB; Convert the tree to a uniform star tree with
// the target sequence at its center.
if (ustar_label != NULL) {
tree = convert_to_uniform_star_tree(tree, ustar_label);
if (tree == NULL)
die("Tree or alignment missing target %s\n", ustar_label);
if (verbosity >= NORMAL_VERBOSE) {
fprintf(stderr,
"Target %s placed at center of uniform (d=%.3f) star tree:\n",
ustar_label, get_total_length(tree) / get_num_children(tree)
);
write_tree(tree, stderr);
}
}
/**********************************************
* Read the motifs.
**********************************************/
char* meme_filename = argv[option_index];
option_index++;
int num_motifs = 0;
MREAD_T *mread;
ALPH_T alph;
ARRAYLST_T *motifs;
ARRAY_T *bg_freqs;
mread = mread_create(meme_filename, OPEN_MFILE);
mread_set_bg_source(mread, bg_filename);
mread_set_pseudocount(mread, pseudocount);
// read motifs
motifs = mread_load(mread, NULL);
alph = mread_get_alphabet(mread);
bg_freqs = mread_get_background(mread);
// check
if (arraylst_size(motifs) == 0) die("No motifs in %s.", meme_filename);
// TLB; need to resize bg_freqs array to ALPH_SIZE items
// or copy array breaks in HB mode. This throws away
// the freqs for the ambiguous characters;
int asize = alph_size(alph, ALPH_SIZE);
resize_array(bg_freqs, asize);
/**************************************************************
* Compute probability distributions for each of the selected motifs.
**************************************************************/
int motif_index;
for (motif_index = 0; motif_index < arraylst_size(motifs); motif_index++) {
MOTIF_T* motif = (MOTIF_T*)arraylst_get(motif_index, motifs);
char* motif_id = get_motif_id(motif);
char* bare_motif_id = motif_id;
// We may have specified on the command line that
// only certain motifs were to be used.
if (selected_motifs != NULL) {
if (*bare_motif_id == '+' || *bare_motif_id == '-') {
// The selected motif id won't included a strand indicator.
bare_motif_id++;
}
if (have_string(bare_motif_id, selected_motifs) == FALSE) {
continue;
}
}
if (verbosity >= NORMAL_VERBOSE) {
fprintf(
stderr,
"Using motif %s of width %d.\n",
motif_id, get_motif_length(motif)
);
}
// Build an array of evolutionary models for each position in the motif.
EVOMODEL_T** models = make_motif_models(
motif,
bg_freqs,
model_type,
fg_rate,
bg_rate,
purine_pyrimidine,
transition_transversion,
use_halpern_bruno
);
// Get the frequencies under the background model (row 0)
// and position-dependent scores (rows 1..w)
// for each possible alignment column.
MATRIX_T* pssm_matrix = build_alignment_pssm_matrix(
alph,
alignment_species,
get_motif_length(motif) + 1,
models,
tree,
gap_support
);
ARRAY_T* alignment_col_freqs = allocate_array(get_num_cols(pssm_matrix));
copy_array(get_matrix_row(0, pssm_matrix), alignment_col_freqs);
remove_matrix_row(0, pssm_matrix); // throw away first row
//print_col_frequencies(alph, alignment_col_freqs);
//
// Get the position-dependent null model alignment column frequencies
//
int w = get_motif_length(motif);
int ncols = get_num_cols(pssm_matrix);
MATRIX_T* pos_dep_bkg = allocate_matrix(w, ncols);
for (i=0; i<w; i++) {
// get the evo model corresponding to this column of the motif
// and store it as the first evolutionary model.
myfree(models[0]);
// Use motif PSFM for equilibrium freqs. for model.
ARRAY_T* site_specific_freqs = allocate_array(asize);
int j = 0;
for(j = 0; j < asize; j++) {
double value = get_matrix_cell(i, j, get_motif_freqs(motif));
set_array_item(j, value, site_specific_freqs);
}
if (use_halpern_bruno == FALSE) {
models[0] = make_model(
model_type,
fg_rate,
transition_transversion,
purine_pyrimidine,
site_specific_freqs,
NULL
);
} else {
models[0] = make_model(
model_type,
fg_rate,
transition_transversion,
purine_pyrimidine,
bg_freqs,
site_specific_freqs
);
}
// get the alignment column frequencies using this model
MATRIX_T* tmp_pssm_matrix = build_alignment_pssm_matrix(
alph,
alignment_species,
2, // only interested in freqs under bkg
models,
tree,
gap_support
);
// assemble the position-dependent background alignment column freqs.
set_matrix_row(i, get_matrix_row(0, tmp_pssm_matrix), pos_dep_bkg);
// chuck the pssm (not his real name)
free_matrix(tmp_pssm_matrix);
}
//
// Compute and print the score distribution under the background model
// and under the (position-dependent) motif model.
//
int range = 10000; // 10^4 gives same result as 10^5, but 10^3 differs
// under background model
PSSM_T* pssm = build_matrix_pssm(alph, pssm_matrix, alignment_col_freqs, range);
// under position-dependent background (motif) model
PSSM_T* pssm_pos_dep = build_matrix_pssm(alph, pssm_matrix, alignment_col_freqs, range);
get_pv_lookup_pos_dep(
pssm_pos_dep,
pos_dep_bkg,
NULL // no priors used
);
// print FP and FN distributions
int num_items = get_pssm_pv_length(pssm_pos_dep);
for (i=0; i<num_items; i++) {
double pvf = get_pssm_pv(i, pssm);
double pvt = get_pssm_pv(i, pssm_pos_dep);
double fpr = pvf;
double fnr = 1 - pvt;
if (fpr >= 0.99999 || fnr == 0) continue;
printf("%s score %d FPR %.3g FNR %.3g\n", motif_id, i, fpr, fnr);
}
// free stuff
free_pssm(pssm);
free_pssm(pssm_pos_dep);
if (models != NULL) {
int model_index;
int num_models = get_motif_length(motif) + 1;
for (model_index = 0; model_index < num_models; model_index++) {
free_model(models[model_index]);
}
myfree(models);
}
} // motif
arraylst_destroy(destroy_motif, motifs);
/**********************************************
* Clean up.
**********************************************/
// TLB may have encountered a memory corruption bug here
// CEG has not been able to reproduce it. valgrind says all is well.
free_array(bg_freqs);
free_tree(TRUE, tree);
free_string_list(selected_motifs);
return(0);
} // main
static int
_parse_line(char *s)
{
char **semi, **comma, *star;
int i, j, n, lasts, lastc, pri;
struct config_rule *out;
if (s == NULL) return -1;
while ((*s == ' ') || (*s == '\t')) s++;
if (*s == '#') return -1;
semi = explode(s, "; \t");
if (semi == NULL) return -1;
out = (struct config_rule *)calloc(1, sizeof(struct config_rule));
if (out == NULL) return -1;
out->fd = -1;
n = 0;
lasts = -1;
for (i = 0; semi[i] != NULL; i++)
{
if (semi[i][0] == '\0') continue;
n++;
lasts = i;
}
out->dst = strdup(semi[lasts]);
if (out->dst == NULL) return -1;
for (i = 0; i < lasts; i++)
{
if (semi[i][0] == '\0') continue;
comma = explode(semi[i], ",.");
lastc = -1;
for (j = 0; comma[j] != NULL; j++)
{
if (comma[j][0] == '\0') continue;
lastc = j;
}
for (j = 0; j < lastc; j++)
{
if (comma[j][0] == '\0') continue;
pri = _level_for_name(comma[lastc]);
if (pri == -1) continue;
if (out->count == 0)
{
out->facility = (char **)calloc(1, sizeof(char *));
out->fac_prefix_len = (uint32_t *)calloc(1, sizeof(uint32_t));
out->pri = (int *)calloc(1, sizeof(int));
}
else
{
out->facility = (char **)reallocf(out->facility, (out->count + 1) * sizeof(char *));
out->fac_prefix_len = (uint32_t *)reallocf(out->fac_prefix_len, (out->count + 1) * sizeof(uint32_t));
out->pri = (int *)reallocf(out->pri, (out->count + 1) * sizeof(int));
}
if (out->facility == NULL) return -1;
if (out->fac_prefix_len == NULL) return -1;
if (out->pri == NULL) return -1;
out->facility[out->count] = _clean_facility_name(comma[j]);
if (out->facility[out->count] == NULL) return -1;
out->fac_prefix_len[out->count] = 0;
star = strchr(out->facility[out->count], '*');
if (star != NULL) out->fac_prefix_len[out->count] = (uint32_t)(star - out->facility[out->count]);
out->pri[out->count] = pri;
out->count++;
}
free_string_list(comma);
}
free_string_list(semi);
TAILQ_INSERT_TAIL(&bsd_out_rule, out, entries);
return 0;
}
/*************************************************************************
* int main
*************************************************************************/
int main(int argc, char *argv[])
{
/* Data structures. */
int num_motifs; /* The number of motifs in the model. */
MOTIF_T motifs[2 * MAX_MOTIFS]; /* The motifs. */
STRING_LIST_T* motif_occurrences = NULL; /* Strings describing occurrences of
motifs */
BOOLEAN_T has_reverse_strand = FALSE; /* MEME file contained both strands */
ARRAY_T* background; /* Background probs for alphabet. */
ORDER_T* order_spacing; /* Linear HMM order and spacing. */
MATRIX_T* transp_freq = NULL; /* Matrix of inter-motif transitions freqs. */
MATRIX_T* spacer_ave = NULL; /* Matrix of average spacer lengths. */
MHMM_T * the_hmm = NULL; /* The HMM being constructed. */
/* Command line parameters. */
char * meme_filename; /* Input file containg motifs. */
char * hmm_type_str; /* HMM type. */
HMM_T hmm_type;
STRING_LIST_T* requested_motifs; /* Indices of requested motifs. */
int request_n; /* The user asked for the first n motifs. */
double e_threshold; /* E-value threshold for motif inclusion. */
double complexity_threshold; // For eliminating low-complexity motifs.
double p_threshold; /* p-value threshold for motif occurences. */
char* order_string; /* Motif order and spacing. */
int spacer_states; /* Number of states in each spacer. */
BOOLEAN_T fim; /* Represent spacers as free insertion
modules? */
BOOLEAN_T keep_unused; // Drop unused inter-motif transitions?
double trans_pseudo; /* Transition pseudocount. */
double spacer_pseudo; // Spacer (self-loop) pseudocount. */
char* description; // Descriptive text to be stored in model.
BOOLEAN_T print_header; /* Print file header? */
BOOLEAN_T print_params; /* Print parameter summary? */
BOOLEAN_T print_time; /* Print timing data (dummy: always false). */
/* Local variables. */
int i_motif;
/**********************************************
* COMMAND LINE PROCESSING
**********************************************/
// Define command line options.
cmdoption const options[] = {
{"type", OPTIONAL_VALUE},
{"description", REQUIRED_VALUE},
{"motif", REQUIRED_VALUE},
{"nmotifs", REQUIRED_VALUE},
{"ethresh", REQUIRED_VALUE},
{"lowcomp", REQUIRED_VALUE},
{"pthresh", REQUIRED_VALUE},
{"order", REQUIRED_VALUE},
{"nspacer", REQUIRED_VALUE},
{"fim", NO_VALUE},
{"keep-unused", NO_VALUE},
{"transpseudo", REQUIRED_VALUE},
{"spacerpseudo", REQUIRED_VALUE},
{"verbosity", REQUIRED_VALUE},
{"noheader", NO_VALUE},
{"noparams", NO_VALUE},
{"notime", NO_VALUE},
{"quiet", NO_VALUE},
};
int option_count = 18;
int option_index = 0;
// Define the usage message.
char usage[1000] = "";
strcat(usage, "USAGE: mhmm [options] <MEME file>\n");
strcat(usage, "\n");
strcat(usage, " Options:\n");
strcat(usage, " --type [linear|complete|star] (default=linear)\n");
strcat(usage, " --description <string> (may be repeated)\n");
strcat(usage, " --motif <motif #> (may be repeated)\n");
strcat(usage, " --nmotifs <#>\n");
strcat(usage, " --ethresh <E-value>\n");
strcat(usage, " --lowcomp <value>\n");
strcat(usage, " --pthresh <p-value>\n");
strcat(usage, " --order <string>\n");
strcat(usage, " --nspacer <spacer length> (default=1)\n");
strcat(usage, " --fim\n");
strcat(usage, " --keep-unused\n");
strcat(usage, " --transpseudo <pseudocount>\n");
strcat(usage, " --spacerpseudo <pseudocount>\n");
strcat(usage, " --verbosity 1|2|3|4|5 (default=2)\n");
strcat(usage, " --noheader\n");
strcat(usage, " --noparams\n");
strcat(usage, " --notime\n");
strcat(usage, " --quiet\n");
strcat(usage, "\n");
/* Make sure various options are set to NULL or defaults. */
meme_filename = NULL;
hmm_type_str = NULL;
hmm_type = INVALID_HMM;
requested_motifs = new_string_list();
request_n = 0;
e_threshold = 0.0;
complexity_threshold = 0.0;
p_threshold = 0.0;
order_string = NULL;
spacer_states = DEFAULT_SPACER_STATES,
fim = FALSE;
keep_unused = FALSE;
trans_pseudo = DEFAULT_TRANS_PSEUDO;
spacer_pseudo = DEFAULT_SPACER_PSEUDO;
description = NULL;
print_header = TRUE;
print_params = TRUE;
print_time = FALSE;
simple_setopt(argc, argv, option_count, options);
// Parse the command line.
while (1) {
int c = 0;
char* option_name = NULL;
char* option_value = NULL;
const char * message = NULL;
// Read the next option, and break if we're done.
c = simple_getopt(&option_name, &option_value, &option_index);
if (c == 0) {
break;
} else if (c < 0) {
simple_getopterror(&message);
die("Error processing command line options (%s)\n", message);
}
if (strcmp(option_name, "type") == 0) {
if (option_value != NULL) {
hmm_type_str = option_value;
}
} else if (strcmp(option_name, "description") == 0) {
description = option_value;
} else if (strcmp(option_name, "motif") == 0) {
add_string(option_value, requested_motifs);
} else if (strcmp(option_name, "nmotifs") == 0) {
request_n = atoi(option_value);
} else if (strcmp(option_name, "ethresh") == 0) {
e_threshold = atof(option_value);
} else if (strcmp(option_name, "lowcomp") == 0) {
complexity_threshold = atof(option_value);
} else if (strcmp(option_name, "pthresh") == 0) {
p_threshold = atof(option_value);
} else if (strcmp(option_name, "order") == 0) {
order_string = option_value;
} else if (strcmp(option_name, "nspacer") == 0) {
spacer_states = atoi(option_value);
} else if (strcmp(option_name, "fim") == 0) {
fim = TRUE;
} else if (strcmp(option_name, "keep-unused") == 0) {
keep_unused = TRUE;
} else if (strcmp(option_name, "transpseudo") == 0) {
trans_pseudo = atof(option_value);
} else if (strcmp(option_name, "spacerpseudo") == 0) {
spacer_pseudo = atof(option_value);
} else if (strcmp(option_name, "verbosity") == 0) {
verbosity = (VERBOSE_T)atoi(option_value);
} else if (strcmp(option_name, "noheader") == 0) {
print_header = FALSE;
} else if (strcmp(option_name, "noparams") == 0) {
print_params = FALSE;
} else if (strcmp(option_name, "notime") == 0) {
print_time = FALSE;
} else if (strcmp(option_name, "quiet") == 0) {
print_header = print_params = print_time = FALSE;
verbosity = QUIET_VERBOSE;
}
}
// Read the single required argument.
if (option_index + 1 != argc) {
fprintf(stderr, "%s", usage);
exit(1);
}
meme_filename = argv[option_index];
// Set up motif requests.
if (request_n != 0) {
if (get_num_strings(requested_motifs) != 0) {
die("Can't combine the -motif and -nmotifs options.\n");
} else {
for (i_motif = 0; i_motif < request_n; i_motif++) {
char motif_id[MAX_MOTIF_ID_LENGTH + 1];
sprintf(motif_id, "%d", i_motif + 1);
add_string(motif_id, requested_motifs);
}
}
}
/* Set the model type. */
hmm_type = convert_enum_type_str(hmm_type_str, LINEAR_HMM, HMM_STRS,
NUM_HMM_T);
/* Gotta have positive spacer length. */
if (spacer_states <= 0) {
die("Negative spacer length (%d).\n", spacer_states);
}
/* Make sure motifs weren't selected redundantly. */
// FIXME: Add tests for complexity threshold.
if ((get_num_strings(requested_motifs) != 0) && (e_threshold != 0.0)) {
die("Can't use -motif or -nmotifs with -ethresh.");
}
if ((get_num_strings(requested_motifs) != 0) && (order_string != NULL)) {
die("Can't use -motif or -nmotifs with -order.");
}
if ((order_string != NULL) && (e_threshold != 0.0)) {
die("Can't use -ethresh and -order.");
}
/* Prevent trying to build a complete or star model with ordering. */
if (order_string != NULL) {
if (hmm_type == COMPLETE_HMM)
die("Can't specify motif order with a completely connected model.");
else if (hmm_type == STAR_HMM)
die("Can't specify motif order with a star model.");
}
// Parse the order string.
order_spacing = create_order(order_string);
/**********************************************
* READING THE MOTIFS
**********************************************/
BOOLEAN_T read_file = FALSE;
double pseudocount = 0;
read_meme_file(
meme_filename,
"motif-file", // Take bg freq. from motif file.
pseudocount,
REQUIRE_PSPM,
&num_motifs,
motifs,
&motif_occurrences,
&has_reverse_strand,
&background
);
process_raw_motifs_for_model(
&num_motifs,
motifs,
motif_occurrences,
requested_motifs,
has_reverse_strand,
keep_unused,
p_threshold,
e_threshold,
complexity_threshold,
&order_spacing,
&transp_freq,
&spacer_ave,
trans_pseudo,
spacer_pseudo
);
/**********************************************
* BUILDING THE HMM
**********************************************/
/* Build the motif-based HMM. */
if (hmm_type == LINEAR_HMM) {
if (order_spacing != NULL) {
reorder_motifs(order_spacing, &num_motifs, motifs);
}
else {
die("No order specified for the motifs.\n"
"For the linear model the motif file must contain motif occurence\n"
"data or the motif order must be specified using "
"the --order option.");
}
build_linear_hmm(
background,
order_spacing,
spacer_states,
motifs,
num_motifs,
fim,
&the_hmm
);
} else if (hmm_type == COMPLETE_HMM) {
build_complete_hmm(
background,
spacer_states,
motifs,
num_motifs,
transp_freq,
spacer_ave,
fim,
&the_hmm
);
} else if (hmm_type == STAR_HMM) {
build_star_hmm(
background,
spacer_states,
motifs,
num_motifs,
fim,
&the_hmm
);
}
// Add some global information.
copy_string(&(the_hmm->motif_file), meme_filename);
/**********************************************
* WRITING THE HMM
**********************************************/
/* Print the header. */
if (print_header)
write_header(
program,
"",
description,
meme_filename,
NULL,
NULL,
stdout
);
/* Write the HMM. */
write_mhmm(verbosity, the_hmm, stdout);
/* Print the program parameters. */
if (print_params) {
printf("Program parameters for mhmm\n");
printf(" MEME file: %s\n", meme_filename);
printf(" Motifs:");
write_string_list(" ", requested_motifs, stdout);
printf("\n");
printf(" Model topology: %s\n",
convert_enum_type(hmm_type, HMM_STRS, NUM_HMM_T));
printf(" States per spacer: %d\n", spacer_states);
printf(" Spacers are free-insertion modules: %s\n",
boolean_to_string(fim));
printf("\n");
}
free_array(background);
free_string_list(requested_motifs);
free_order(order_spacing);
free_matrix(transp_freq);
free_matrix(spacer_ave);
for (i_motif = 0; i_motif < num_motifs; i_motif++)
free_motif(&(motifs[i_motif]));
free_mhmm(the_hmm);
return(0);
}
static void
sync_chans( main_vars_t *mvars, int ent )
{
group_conf_t *group;
channel_conf_t *chan;
store_t *store;
string_list_t *mbox, *sbox, **mboxp, **sboxp;
char *channame;
int t;
if (!mvars->cben)
return;
switch (ent) {
case E_OPEN: goto opened;
case E_SYNC: goto syncone;
}
for (;;) {
mvars->boxlist = 0;
if (!mvars->all) {
if (mvars->chanptr)
channame = mvars->chanptr->string;
else {
for (group = groups; group; group = group->next)
if (!strcmp( group->name, mvars->argv[mvars->oind] )) {
mvars->chanptr = group->channels;
channame = mvars->chanptr->string;
goto gotgrp;
}
channame = mvars->argv[mvars->oind];
gotgrp: ;
}
if ((mvars->boxlist = strchr( channame, ':' )))
*mvars->boxlist++ = 0;
for (chan = channels; chan; chan = chan->next)
if (!strcmp( chan->name, channame ))
goto gotchan;
error( "No channel or group named '%s' defined.\n", channame );
mvars->ret = 1;
goto gotnone;
gotchan:
mvars->chan = chan;
}
merge_actions( mvars->chan, mvars->ops, XOP_HAVE_TYPE, OP_MASK_TYPE, OP_MASK_TYPE );
merge_actions( mvars->chan, mvars->ops, XOP_HAVE_CREATE, OP_CREATE, 0 );
merge_actions( mvars->chan, mvars->ops, XOP_HAVE_EXPUNGE, OP_EXPUNGE, 0 );
mvars->state[M] = mvars->state[S] = ST_FRESH;
info( "Channel %s\n", mvars->chan->name );
mvars->boxes[M] = mvars->boxes[S] = mvars->cboxes = 0;
mvars->skip = mvars->cben = 0;
for (t = 0; t < 2; t++) {
mvars->drv[t] = mvars->chan->stores[t]->driver;
if ((store = mvars->drv[t]->own_store( mvars->chan->stores[t] )))
store_opened( store, AUX );
}
for (t = 0; t < 2 && !mvars->skip; t++)
if (mvars->state[t] == ST_FRESH) {
info( "Opening %s %s...\n", str_ms[t], mvars->chan->stores[t]->name );
mvars->drv[t]->open_store( mvars->chan->stores[t], store_opened, AUX );
}
mvars->cben = 1;
opened:
if (mvars->skip)
goto next;
if (mvars->state[M] != ST_OPEN || mvars->state[S] != ST_OPEN)
return;
if (mvars->boxlist)
mvars->boxp = mvars->boxlist;
else if (mvars->chan->patterns) {
mvars->boxes[M] = filter_boxes( mvars->ctx[M]->boxes, mvars->chan->patterns );
mvars->boxes[S] = filter_boxes( mvars->ctx[S]->boxes, mvars->chan->patterns );
for (mboxp = &mvars->boxes[M]; (mbox = *mboxp); ) {
for (sboxp = &mvars->boxes[S]; (sbox = *sboxp); sboxp = &sbox->next)
if (!strcmp( sbox->string, mbox->string )) {
*sboxp = sbox->next;
free( sbox );
*mboxp = mbox->next;
mbox->next = mvars->cboxes;
mvars->cboxes = mbox;
goto gotdupe;
}
mboxp = &mbox->next;
gotdupe: ;
}
}
if (mvars->list && mvars->multiple)
printf( "%s:\n", mvars->chan->name );
syncml:
mvars->done = mvars->cben = 0;
syncmlx:
if (mvars->boxlist) {
if ((mvars->names[S] = strsep( &mvars->boxp, ",\n" ))) {
if (!*mvars->names[S])
mvars->names[S] = 0;
if (!mvars->list) {
mvars->names[M] = mvars->names[S];
sync_boxes( mvars->ctx, mvars->names, mvars->chan, done_sync, mvars );
goto syncw;
}
puts( nz( mvars->names[S], "INBOX" ) );
goto syncmlx;
}
} else if (mvars->chan->patterns) {
if ((mbox = mvars->cboxes)) {
mvars->cboxes = mbox->next;
if (!mvars->list) {
mvars->names[M] = mvars->names[S] = mbox->string;
sync_boxes( mvars->ctx, mvars->names, mvars->chan, done_sync_dyn, mvars );
goto syncw;
}
puts( mbox->string );
free( mbox );
goto syncmlx;
}
for (t = 0; t < 2; t++)
if ((mbox = mvars->boxes[t])) {
mvars->boxes[t] = mbox->next;
if ((mvars->chan->ops[1-t] & OP_MASK_TYPE) && (mvars->chan->ops[1-t] & OP_CREATE)) {
if (!mvars->list) {
mvars->names[M] = mvars->names[S] = mbox->string;
sync_boxes( mvars->ctx, mvars->names, mvars->chan, done_sync_dyn, mvars );
goto syncw;
}
puts( mbox->string );
}
free( mbox );
goto syncmlx;
}
} else {
if (!mvars->list) {
sync_boxes( mvars->ctx, mvars->chan->boxes, mvars->chan, done_sync, mvars );
mvars->skip = 1;
syncw:
mvars->cben = 1;
if (!mvars->done)
return;
syncone:
if (!mvars->skip)
goto syncml;
} else
printf( "%s <=> %s\n", nz( mvars->chan->boxes[M], "INBOX" ), nz( mvars->chan->boxes[S], "INBOX" ) );
}
next:
for (t = 0; t < 2; t++)
if (mvars->state[t] == ST_OPEN) {
mvars->drv[t]->disown_store( mvars->ctx[t] );
mvars->state[t] = ST_CLOSED;
}
if (mvars->state[M] != ST_CLOSED || mvars->state[S] != ST_CLOSED) {
mvars->skip = mvars->cben = 1;
return;
}
free_string_list( mvars->cboxes );
free_string_list( mvars->boxes[M] );
free_string_list( mvars->boxes[S] );
if (mvars->all) {
if (!(mvars->chan = mvars->chan->next))
break;
} else {
if (mvars->chanptr && (mvars->chanptr = mvars->chanptr->next))
continue;
gotnone:
if (!mvars->argv[++mvars->oind])
break;
}
}
for (t = 0; t < N_DRIVERS; t++)
drivers[t]->cleanup();
}
/* The main window */
GtkWidget *logstats_prefs (struct widget *w)
{
GtkWidget *ret, *vbox, *hbox;
GtkWidget *label, *button, *entry, *sw;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *col;
GtkTreeIter iter;
GList *aliases, *aliases_start;
ret = gtk_vbox_new (FALSE, 6);
/* Checkbox for enabling/disabling */
checkbox = gtk_check_button_new_with_mnemonic (
"Enable statistics for logs");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(checkbox),
purple_prefs_get_bool (
"/plugins/gtk/autoprofile/components/logstat/enabled"));
gtk_box_pack_start (GTK_BOX(ret), checkbox, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX(ret), vbox, TRUE, TRUE, 0);
/* Le format string */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL(label), "<b>Format string for output</b>");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX(vbox), entry, FALSE, FALSE, 0);
gtk_entry_set_max_length (GTK_ENTRY(entry), 1000);
gtk_entry_set_text (GTK_ENTRY(entry), purple_prefs_get_string (
"/plugins/gtk/autoprofile/components/logstat/format"));
g_signal_connect (G_OBJECT (entry), "focus-out-event",
G_CALLBACK (logstat_format), NULL);
label = gtk_label_new (_(
"%R\tTotal messages received\n"
"%r\tTotal words received\n"
"%S\tTotal messages sent\n"
"%s\tTotal words sent\n"
"%T\tTotal messages sent/received\n"
"%t\tTotal words sent/received\n"
"%D\tNumber of days since first logged conversation\n"
"%d\tNumber of days with logged conversations\n"
"%N\tNumber of logged conversations\n"
"%n\tAverage number of conversations per day with logs\n"
"%i\tMost conversations in a single day\n"
"%I\tDate with most conversations\n"
"%j\tMost messages sent in a single day\n"
"%J\tDate with most messages sent\n"
"%k\tMost messages received in a single day\n"
"%K\tDate with most messages received\n"
"%l\tMost total messages sent/received in a single day\n"
"%L\tDate with most total messages sent/received\n"
"%f\tDate of first logged conversation\n"
"%u\tAverage words per message received\n"
"%v\tAverage words per message sent\n"
"%w\tAverage words per message sent/received\n"
"%U\tAverage messages received per conversation\n"
"%V\tAverage messages sent per conversation\n"
"%W\tAverage messages sent/received per conversation\n"
"%x\tAverage words received per day with logs\n"
"%y\tAverage words sent per day with logs\n"
"%z\tAverage words sent/received per day with logs\n"
"%X\tAverage messages received per day with logs\n"
"%Y\tAverage messages sent per day with logs\n"
"%Z\tAverage messages sent/received per day with logs\n"
"%p\tPercentage of days with logs\n"
"%a\tNumber of messages received today\n"
"%b\tNumber of messages sent today\n"
"%c\tNumber of conversations started today\n"
"%e\tNumber of messages sent/received today\n"
"%A\tNumber of messages received in last week\n"
"%B\tNumber of messages sent in last week\n"
"%C\tNumber of conversations started in last week\n"
"%E\tNumber of messages sent/received in last week\n"
"%%\t%"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
sw = gtk_scrolled_window_new (NULL,NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE , 0);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(sw), label);
/* Aliases */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL(label), "<b>Personal aliases</b>");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL(label),
"You need this if you have an alias for your own screen name,\n"
"else IM's you sent will be incorrectly counted as received");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label (_("Add alias"));
g_signal_connect (G_OBJECT(button), "clicked",
G_CALLBACK (alias_add), NULL);
gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label (_("Delete alias"));
g_signal_connect (G_OBJECT(button), "clicked",
G_CALLBACK (alias_delete), NULL);
gtk_box_pack_start (GTK_BOX(hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label (_("?"));
g_signal_connect (G_OBJECT(button), "clicked",
G_CALLBACK (alias_what), NULL);
gtk_box_pack_start (GTK_BOX(hbox), button, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (0, 0);
gtk_box_pack_start (GTK_BOX(vbox), sw, FALSE, FALSE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
alias_list = gtk_list_store_new (1, G_TYPE_STRING);
alias_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (alias_list));
gtk_container_add (GTK_CONTAINER(sw), alias_view);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(alias_view), FALSE);
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (alias_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
col = gtk_tree_view_column_new_with_attributes (
_("Alias"), renderer, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(alias_view), col);
aliases = purple_prefs_get_string_list (
"/plugins/gtk/autoprofile/components/logstat/aliases");
aliases_start = aliases;
while (aliases) {
gtk_list_store_append (alias_list, &iter);
gtk_list_store_set (alias_list, &iter,
0, (char *)aliases->data, -1);
aliases = aliases->next;
}
free_string_list (aliases_start);
/* Finish up the checkbox stuff */
g_signal_connect (G_OBJECT(checkbox), "clicked",
G_CALLBACK(toggle_enable), vbox);
if (!purple_prefs_get_bool (
"/plugins/gtk/autoprofile/components/logstat/enabled")) {
gtk_widget_set_sensitive (vbox, FALSE);
} else {
gtk_widget_set_sensitive (vbox, TRUE);
}
return ret;
}
/*
* Used to set config parameters.
* Line format "= name value"
*/
static void
_aslmanager_set_param(asl_out_dst_data_t *dst, char *s)
{
char **l;
uint32_t count;
if (s == NULL) return;
if (s[0] == '\0') return;
/* skip '=' and whitespace */
if (*s == '=') s++;
while ((*s == ' ') || (*s == '\t')) s++;
l = explode(s, " \t");
if (l == NULL) return;
for (count = 0; l[count] != NULL; count++);
/* name is required */
if (count == 0)
{
free_string_list(l);
return;
}
/* value is required */
if (count == 1)
{
free_string_list(l);
return;
}
if (!strcasecmp(l[0], "aslmanager_debug"))
{
/* = debug level */
set_debug(DEBUG_ASL, l[1]);
}
else if (!strcasecmp(l[0], "store_ttl"))
{
/* = store_ttl days */
dst->ttl[LEVEL_ALL] = (time_t)atoll(l[1]);
}
else if (!strcasecmp(l[0], "module_ttl"))
{
/* = module_ttl days */
module_ttl = (time_t)atoll(l[1]);
}
else if (!strcasecmp(l[0], "max_store_size"))
{
/* = max_file_size bytes */
dst->all_max = atoi(l[1]);
}
else if (!strcasecmp(l[0], "archive"))
{
free(dst->rotate_dir);
dst->rotate_dir = NULL;
/* = archive {0|1} path */
if (!strcmp(l[1], "1"))
{
if (l[2] == NULL) dst->rotate_dir = strdup(PATH_ASL_ARCHIVE);
else dst->rotate_dir = strdup(l[2]);
}
}
else if (!strcasecmp(l[0], "store_path"))
{
/* = archive path */
free(dst->path);
dst->path = strdup(l[1]);
}
else if (!strcasecmp(l[0], "archive_mode"))
{
dst->mode = strtol(l[1], NULL, 0);
if ((dst->mode == 0) && (errno == EINVAL)) dst->mode = 0400;
}
free_string_list(l);
}
