static void
_gtk_source_completion_container_get_preferred_width (GtkWidget *widget,
gint *min_width,
gint *nat_width)
{
GtkSourceCompletionContainer *container = GTK_SOURCE_COMPLETION_CONTAINER (widget);
GtkWidget *child;
GtkRequisition nat_size;
gint width;
child = gtk_bin_get_child (GTK_BIN (container));
gtk_widget_get_preferred_size (child, NULL, &nat_size);
width = MIN (nat_size.width, get_max_width (container));
if (min_width != NULL)
{
*min_width = width;
}
if (nat_width != NULL)
{
*nat_width = width;
}
g_return_if_fail (width >= 0);
}
void memory_open (zword table, zword xsize, bool buffering)
{
if (++depth < MAX_NESTING) {
if (!buffering)
xsize = 0xffff;
else {
if ((short) xsize >= 0)
xsize = get_max_width (xsize);
else
xsize = -xsize;
}
storew (table, 0);
redirect[depth].table = table;
redirect[depth].width = 0;
redirect[depth].total = 0;
redirect[depth].xsize = xsize;
ostream_memory = TRUE;
} else runtime_error (ERR_STR3_NESTING);
}/* memory_open */
void file_menu::display_current_files() {
std::vector<std::string> to_show;
if (!is_root(current_dir_)) {
to_show.push_back(path_up);
}
std::vector<std::string>::iterator it;
for (it = dirs_in_current_dir_.begin(); it != dirs_in_current_dir_.end(); ++it) {
// Add an image to show that these are directories.
std::stringstream ss;
ss << font::IMAGE << dir_picture << COLUMN_SEPARATOR << font::NULL_MARKUP << *it;
to_show.push_back(ss.str());
}
for (it = files_in_current_dir_.begin(); it != files_in_current_dir_.end(); ++it) {
const std::string display_string = COLUMN_SEPARATOR + std::string(1, font::NULL_MARKUP) + *it;
to_show.push_back(display_string);
}
const int menu_font_size = font::SIZE_NORMAL; // Known from menu.cpp.
for (it = to_show.begin(); it != to_show.end(); ++it) {
// Make sure that all lines fit.
// Guess the width of the scrollbar to be 30 since it is not accessible from here.
// -25 to compensate for the picture column.
if (get_max_width() != -1) {
while(font::line_width(*it, menu_font_size) > width() - 30 - 25) {
//we cannot decrease its size if its empty.
assert(!(*it).empty());
(*it).resize((*it).size() - 1);
}
}
}
set_items(to_show);
}
/**
* search_matrix_partition
*
* Searches the specified partition of the matrix, for the S_POINT with the
* smallest significance value.
*
* \return The S_POINT with the smallest significance value. Returns NULL if no
* S_POINT (in the partition) had a significance less than BIG.
*/
static S_POINT *search_matrix_partition (
SP_MATRIX *sp_mat, ///< The matrix containing the partition of interest
DATASET *data, ///< Sequence dataset.
MODEL *model, ///< The nascent motif model. Contains parameters needed
///< in order to calculate significance of scores
PARTITION *part ///< The coordinates of the partition within the matrix
) {
// Consider each S_POINT in the partition. Find the S_POINT with the
// smallest significance value...
double curr_best_sig = BIG;
S_POINT *curr_best_sp = NULL;
int curr_w, curr_n;
for (curr_w = part->min_w; curr_w <= part->max_w; curr_w++) {
assert (curr_w <= get_max_width(sp_mat));
for (curr_n = part->min_n; curr_n <= part->max_n; curr_n++) {
assert (curr_n <= get_max_nsites(sp_mat));
int w_idx = curr_w - get_min_width(sp_mat);
int n_idx = curr_n - get_min_nsites(sp_mat);
// Get the current S_POINT from the SP_MATRIX:
S_POINT *curr_sp = get_spoint(sp_mat, w_idx, n_idx);
// Only consider the current s_point if it has been initialised. Note
// that (spoint initialised <==> contains non-empty cons0 string):
double curr_sig = BIG; // s_point is non-significant by default.
if ((curr_sp->cons0 != NULL) && (strcmp(curr_sp->cons0, "") != 0)) {
curr_sig = get_log_sig(
curr_sp->score,
model->mtype,
curr_sp->w0,
curr_sp->wgt_nsites,
curr_sp->nsites0,
model->invcomp,
model->pal,
data
);
curr_sp->sig = curr_sig;
if (curr_sig <= curr_best_sig) {
curr_best_sig = curr_sig;
curr_best_sp = curr_sp;
}
} // Only considering s_point if initialised
} // curr_n
} // curr_w
return curr_best_sp;
} // search_matrix_partition
/**
* create_partitions
*
* Generate a list of PARTITION objects, which store the coordinates of blocks
* in the matrix. These blocks can then be considered in the future - eg
* for the purpose of choosing a list of EM starts from the matrix. The
* array of partitions objects is referenced by the sp_matrix.
*
*/
static void create_partitions (
SP_MATRIX *sp_mat ///< The sp_matrix object
///< Currently no parameters. May allow user manipulation later.
) {
/* For every central s_point (ie s_point with central w and n) in the
* matrix, calculate the boundaries of the current partition and then
* generate a partition that fits within those bounds... */
int *central_widths = get_central_ws(sp_mat);
int *central_nsites = get_central_ns(sp_mat);
int w_idx;
int n_partitions = 0;
PARTITION **part_array = NULL;
for (w_idx = 0; w_idx < get_num_central_widths(sp_mat); w_idx++) {
int n_idx;
for (n_idx = 0; n_idx < get_num_central_nsites(sp_mat); n_idx++) {
int curr_w = central_widths[w_idx];
int curr_n = central_nsites[n_idx];
/* Calculate the boundaries within which the current partition must
* be located. The boundaries are half way between the current
* value and the adjacent value, unless there is no adjacent value
* (in which case the boundary IS the current value):
*/
double min_w_bounds, max_w_bounds, min_n_bounds, max_n_bounds;
if (curr_w == get_min_width(sp_mat)) {
min_w_bounds = curr_w;
} else {
int prev_w = central_widths[w_idx - 1];
min_w_bounds = (curr_w + prev_w)/(double)2;
}
if (curr_w == get_max_width(sp_mat)) {
max_w_bounds = curr_w;
} else {
int next_w = central_widths[w_idx + 1];
max_w_bounds = (curr_w + next_w)/(double)2;
}
if (curr_n == get_min_nsites(sp_mat)) {
min_n_bounds = curr_n;
} else {
int prev_n = central_nsites[n_idx - 1];
min_n_bounds = (curr_n + prev_n)/(double)2;
}
if (curr_n == get_max_nsites(sp_mat)) {
max_n_bounds = curr_n;
} else {
int next_n = central_nsites[n_idx + 1];
max_n_bounds = (curr_n + next_n)/(double)2;
}
/* Calculate the minimum and maximum w and n values which define the
current partition. The minimum value is the smallest integer that is
>= the minimum boundary. The maximum value is the largest integer that
is < the maximum boundary, unless the maximum boundary is the max
value in the sp_matrix (in which case the maximum value is the
maximum boundary itself). This ensures that every s_point in the
matrix will be assigned to a partition.
*/
int part_min_w, part_max_w, part_min_n, part_max_n;
part_min_w = (int)ceil(min_w_bounds);
part_min_n = (int)ceil(min_n_bounds);
if (curr_w == get_max_width(sp_mat)) {
part_max_w = curr_w;
} else {
// Largest integer LESS than max bounds:
if (max_w_bounds == ceil(max_w_bounds)) {
part_max_w = (int)max_w_bounds - 1;
} else {
part_max_w = (int)floor(max_w_bounds);
}
}
if (curr_n == get_max_nsites(sp_mat)) {
part_max_n = curr_n;
} else {
// Largest integer LESS than max bounds:
if (max_n_bounds == ceil(max_n_bounds)) {
part_max_n = (int)max_n_bounds - 1;
} else {
part_max_n = (int)floor(max_n_bounds);
}
}
// Generate the current partition and add it to the growing array:
PARTITION *curr_part = new_partition(part_min_w, part_max_w, curr_w,
part_min_n, part_max_n, curr_n);
(n_partitions)++;
Resize(part_array, n_partitions, PARTITION *);
part_array[(n_partitions) - 1] = curr_part;
} // n_idx
} // w_idx
assert(sp_mat->partitions == NULL);
sp_mat->partitions = part_array;
sp_mat->n_parts = n_partitions;
} // create_partitions
/**
* sp_get_num_rows
*
* \return The number of different widths encompassed by this matrix. This
* is equal to the number of rows in the matrix.
*
*/
int sp_get_num_rows (
SP_MATRIX *sp_mat
) {
return (get_max_width(sp_mat) - get_min_width(sp_mat) + 1);
}