bool
range_in_range(const struct range *rg, const struct range *subrg)
{
return range_valid(subrg)
&& subrg->rg_from >= rg->rg_from
&& subrg->rg_to <= rg->rg_to;
}
TEST(TestHttpRange, Ctor)
{
const uint64_t validFirstPosition = 10;
const uint64_t validLastPosition = 25;
const uint64_t invalidLastPosition = 5;
const uint64_t validLength = validLastPosition - validFirstPosition + 1;
CHttpRange range_invalid(validFirstPosition, invalidLastPosition);
EXPECT_EQ(validFirstPosition, range_invalid.GetFirstPosition());
EXPECT_EQ(invalidLastPosition, range_invalid.GetLastPosition());
EXPECT_EQ(DefaultLength, range_invalid.GetLength());
EXPECT_FALSE(range_invalid.IsValid());
CHttpRange range_valid(validFirstPosition, validLastPosition);
EXPECT_EQ(validFirstPosition, range_valid.GetFirstPosition());
EXPECT_EQ(validLastPosition, range_valid.GetLastPosition());
EXPECT_EQ(validLength, range_valid.GetLength());
EXPECT_TRUE(range_valid.IsValid());
}
/**
* range_transpose:
* @range: The range.
* @sheet : the sheet in which @range lives
* @boundary: The box to transpose inside
*
* Effectively mirrors the ranges in 'boundary' around a
* leading diagonal projected from offset.
*
* Return value: whether we clipped the range.
**/
gboolean
range_transpose (GnmRange *range, Sheet const *sheet, GnmCellPos const *origin)
{
gboolean clipped = FALSE;
GnmRange src;
int t;
int last_col = gnm_sheet_get_last_col (sheet);
int last_row = gnm_sheet_get_last_row (sheet);
g_return_val_if_fail (range != NULL, TRUE);
src = *range;
/* Start col */
t = origin->col + (src.start.row - origin->row);
if (t > last_col) {
clipped = TRUE;
range->start.col = last_col;
} else if (t < 0) {
clipped = TRUE;
range->start.col = 0;
}
range->start.col = t;
/* Start row */
t = origin->row + (src.start.col - origin->col);
if (t > last_row) {
clipped = TRUE;
range->start.row = last_row;
} else if (t < 0) {
clipped = TRUE;
range->start.row = 0;
}
range->start.row = t;
/* End col */
t = origin->col + (src.end.row - origin->row);
if (t > last_col) {
clipped = TRUE;
range->end.col = last_col;
} else if (t < 0) {
clipped = TRUE;
range->end.col = 0;
}
range->end.col = t;
/* End row */
t = origin->row + (src.end.col - origin->col);
if (t > last_row) {
clipped = TRUE;
range->end.row = last_row;
} else if (t < 0) {
clipped = TRUE;
range->end.row = 0;
}
range->end.row = t;
g_assert (range_valid (range));
return clipped;
}
/**
* gnm_ft_calculate:
* @origft: GnmFT
* @s: Target range
* @pc: Callback function
* @cb_data: Data to pass to the callback function
*
* Calculate all styles for a range of @s. This routine will invoke the callback function
* and pass all styles and ranges for those styles to the callback function.
* The callback function should UNREF the mstyle passed!
*
**/
static void
gnm_ft_calculate (GnmFT *origft, GnmRange const *r,
PCalcCallback pc, gpointer cb_data)
{
GnmFT *ft = origft;
GSList *ptr;
g_return_if_fail (origft != NULL);
if (!ft->edges.left || !ft->edges.right || !ft->edges.top || !ft->edges.bottom)
ft = gnm_auto_fmt_filter_edges (origft);
for (ptr = ft->members; NULL != ptr ; ptr = ptr->next) {
GnmFTMember const *member = ptr->data;
GnmStyle const *mstyle = member->mstyle;
GnmRange range = gnm_ft_member_get_rect (member, r);
g_return_if_fail (range_valid (&range));
if (member->direction == FREQ_DIRECTION_NONE)
pc (ft, &range, gnm_style_dup (mstyle), cb_data);
else if (member->direction == FREQ_DIRECTION_HORIZONTAL) {
int col_repeat = member->repeat;
GnmRange hr = range;
while (col_repeat != 0) {
pc (ft, &hr, gnm_style_dup (mstyle), cb_data);
hr.start.col += member->skip + member->col.size;
hr.end.col += member->skip + member->col.size;
if (member->repeat != -1)
col_repeat--;
else {
if (hr.start.row > r->end.row)
break;
}
if (hr.start.row > r->end.row - member->edge)
break;
}
} else if (member->direction == FREQ_DIRECTION_VERTICAL) {
int row_repeat = member->repeat;
GnmRange vr = range;
while (row_repeat != 0) {
pc (ft, &vr, gnm_style_dup (mstyle), cb_data);
vr.start.row += member->skip + member->row.size;
vr.end.row += member->skip + member->row.size;
if (member->repeat != -1)
row_repeat--;
else {
if (vr.start.row > r->end.row)
break;
}
if (vr.start.row > r->end.row - member->edge)
break;
}
}
}
if (ft != origft)
gnm_ft_free (ft);
}
/**
* format_template_range_check:
* @ft: Format template
* @r: Target range
* @optional_cc: if non-NULL display an error message if @r is not
* appropriate for @ft.
*
* Check whether range @r is big enough to apply format template @ft to it.
*
* Return value: TRUE if @s is big enough, FALSE if not.
**/
static gboolean
format_template_range_check (GnmFT *ft, GnmRange const *r,
GOCmdContext *optional_cc)
{
GSList *ptr;
int diff_col_high = -1;
int diff_row_high = -1;
gboolean invalid_range_seen = FALSE;
g_return_val_if_fail (ft != NULL, FALSE);
for (ptr = ft->members; NULL != ptr ; ptr = ptr->next) {
GnmFTMember *member = ptr->data;
GnmRange range = gnm_ft_member_get_rect (member, r);
if (!range_valid (&range)) {
int diff_col = (range.start.col - range.end.col);
int diff_row = (range.start.row - range.end.row);
if (diff_col > diff_col_high)
diff_col_high = diff_col;
if (diff_row > diff_row_high)
diff_row_high = diff_row;
invalid_range_seen = TRUE;
}
}
if (invalid_range_seen && optional_cc != NULL) {
int diff_row_high_ft = diff_row_high + range_height (r);
int diff_col_high_ft = diff_col_high + range_width (r);
char *errmsg;
char *rows, *cols;
if (diff_col_high > 0 && diff_row_high > 0) {
rows = g_strdup_printf (ngettext ("%d row", "%d rows", diff_row_high_ft), diff_row_high_ft);
cols = g_strdup_printf (ngettext ("%d col", "%d cols", diff_col_high_ft), diff_col_high_ft);
errmsg = g_strdup_printf (
_("The target region is too small. It should be at least %s by %s"),
rows, cols);
g_free (rows);
g_free (cols);
} else if (diff_col_high > 0)
errmsg = g_strdup_printf (
ngettext ("The target region is too small. It should be at least %d column wide",
"The target region is too small. It should be at least %d columns wide",
diff_col_high_ft),
diff_col_high_ft);
else if (diff_row_high > 0)
errmsg = g_strdup_printf (
ngettext ("The target region is too small. It should be at least %d row high",
"The target region is too small. It should be at least %d rows high",
diff_row_high_ft),
diff_row_high_ft);
else {
errmsg = NULL;
g_warning ("Internal error while verifying ranges! (this should not happen!)");
}
if (errmsg != NULL) {
go_cmd_context_error_system (optional_cc, errmsg);
g_free (errmsg);
}
}
return !invalid_range_seen;
}
