static cv_t default_handler(obj_t cont, obj_t values)
{
/*
* For all non-message-irritants-who conditions,
* print the condition's class.
* For all message conditions, print the condition's message.
* If who or irritants given, print (cons who irritants).
*/
assert(is_cont(cont));
EVAL_LOG("cont=%O values=%O", cont, values);
obj_t ex = CAR(values);
obj_t parts = record_get_field(ex, 0);
const char *psn = program_short_name();
size_t psnl = strlen(psn);
size_t i, size = vector_len(parts);
for (i = 0; i < size; i++) {
obj_t rtd = record_rtd(vector_ref(parts, i));
if (rtd != message && rtd != irritants && rtd != who) {
ofprintf(stderr, "%*s: %O\n", (int)psnl, psn, rtd_name(rtd));
psn = "";
}
}
obj_t who_p = FALSE_OBJ;
obj_t irr_p = make_uninitialized();
for (i = 0; i < size; i++) {
obj_t p = vector_ref(parts, i);
obj_t rtd = record_rtd(p);
if (rtd == message) {
obj_t msg = record_get_field(p, 0);
const wchar_t *chars = string_value(msg);
fprintf(stderr, "%*s %ls\n", (int)psnl, psn, chars);
psn = "";
} else if (rtd == who)
who_p = record_get_field(p, 0);
else if (rtd == irritants)
irr_p = record_get_field(p, 0);
}
if (who_p != FALSE_OBJ && !is_uninitialized(irr_p)) {
ofprintf(stderr, "%*s %O\n", (int)psnl, psn, CONS(who_p, irr_p));
psn = "";
} else if (who_p != FALSE_OBJ) {
ofprintf(stderr, "%*s %O\n", (int)psnl, psn, who_p);
psn = "";
} else if (!is_uninitialized(irr_p)) {
ofprintf(stderr, "%*s %O\n", (int)psnl, psn, irr_p);
psn = "";
}
if (*psn)
fprintf(stderr, "%s: unknown exception\n", psn);
ofprintf(stderr, "\n");
return cv(EMPTY_LIST, CONS(make_uninitialized(), EMPTY_LIST));
}
void VerificationType::print_on(outputStream* st) const {
switch (_u._data) {
case Bogus: st->print("top"); break;
case Category1: st->print("category1"); break;
case Category2: st->print("category2"); break;
case Category2_2nd: st->print("category2_2nd"); break;
case Boolean: st->print("boolean"); break;
case Byte: st->print("byte"); break;
case Short: st->print("short"); break;
case Char: st->print("char"); break;
case Integer: st->print("integer"); break;
case Float: st->print("float"); break;
case Long: st->print("long"); break;
case Double: st->print("double"); break;
case Long_2nd: st->print("long_2nd"); break;
case Double_2nd: st->print("double_2nd"); break;
case Null: st->print("null"); break;
case ReferenceQuery: st->print("reference type"); break;
case Category1Query: st->print("category1 type"); break;
case Category2Query: st->print("category2 type"); break;
case Category2_2ndQuery: st->print("category2_2nd type"); break;
default:
if (is_uninitialized_this()) {
st->print("uninitializedThis");
} else if (is_uninitialized()) {
st->print("uninitialized %d", bci());
} else {
name()->print_value_on(st);
}
}
}
obj_t symbol_name(obj_t symbol)
{
CHECK_OBJ(symbol);
CHECK(is_symbol(symbol), "must be symbol", symbol);
obj_t name = fixvec1_get_ptr(symbol, 0);
if (is_uninitialized(name)) {
size_t max_len = 12;
ssize_t name_len;
wchar_t name_buf[max_len];
while (true) {
name_len = swprintf(name_buf, max_len,
L"g%04d", ++gen_name_counter);
assert(0 <= name_len && name_len < max_len);
name = make_string_from_chars(name_buf, name_len);
if (!is_null(find_symbol(name)))
continue;
/* with lock */ {
/* verify symbol still absent */
fixvec1_set_ptr(symbol, 0, name);
all_symbols_list = make_pair(symbol, all_symbols_list);
}
break;
}
}
return name;
}
void init_records(void)
{
rec_descriptor_t *desc;
bool done;
do {
done = true;
for (desc = rec_descs; desc; desc = desc->rd_next) {
if (desc->rd_initialized)
continue;
if (desc->rd_parent && is_uninitialized(*desc->rd_parent)) {
done = false;
continue;
} else {
init_rec(desc);
desc->rd_initialized = true;
}
}
} while (!done);
}
static void
ide_frame_pan_end (IdeFrame *self,
GdkEventSequence *sequence,
GtkGesturePan *gesture)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
IdeFramePrivate *dest_priv;
IdeFrame *dest;
GtkAllocation alloc;
GtkWidget *grid;
GtkWidget *column;
gdouble x, y;
gint direction;
gint index = 0;
IDE_ENTRY;
g_assert (IDE_IS_FRAME (self));
g_assert (GTK_IS_GESTURE_PAN (gesture));
if (priv->pan_theatric == NULL || priv->pan_page == NULL)
IDE_GOTO (cleanup);
gtk_widget_get_allocation (GTK_WIDGET (self), &alloc);
gtk_gesture_drag_get_offset (GTK_GESTURE_DRAG (gesture), &x, &y);
if (x > DISTANCE_THRESHOLD (&alloc))
direction = 1;
else if (x < -DISTANCE_THRESHOLD (&alloc))
direction = -1;
else
direction = 0;
grid = gtk_widget_get_ancestor (GTK_WIDGET (self), IDE_TYPE_GRID);
g_assert (grid != NULL);
g_assert (IDE_IS_GRID (grid));
column = gtk_widget_get_ancestor (GTK_WIDGET (self), IDE_TYPE_GRID_COLUMN);
g_assert (column != NULL);
g_assert (IDE_IS_GRID_COLUMN (column));
gtk_container_child_get (GTK_CONTAINER (grid), GTK_WIDGET (column),
"index", &index,
NULL);
dest = _ide_grid_get_nth_stack (IDE_GRID (grid), index + direction);
dest_priv = ide_frame_get_instance_private (dest);
g_assert (dest != NULL);
g_assert (IDE_IS_FRAME (dest));
gtk_widget_get_allocation (GTK_WIDGET (dest), &alloc);
if (!is_uninitialized (&alloc))
{
AnimationState *state;
state = g_slice_new0 (AnimationState);
state->source = g_object_ref (self);
state->dest = g_object_ref (dest);
state->page = g_object_ref (priv->pan_page);
state->theatric = g_object_ref (priv->pan_theatric);
gtk_widget_translate_coordinates (GTK_WIDGET (dest_priv->top_stack), grid, 0, 0,
&alloc.x, &alloc.y);
/*
* Use EASE_OUT_CUBIC, because user initiated the beginning of the
* acceleration curve just by swiping. No need to duplicate.
*/
dzl_object_animate_full (state->theatric,
DZL_ANIMATION_EASE_OUT_CUBIC,
TRANSITION_DURATION,
gtk_widget_get_frame_clock (GTK_WIDGET (self)),
animation_state_complete,
state,
"x", alloc.x,
"width", alloc.width,
NULL);
if (dest != self)
{
g_ptr_array_add (priv->in_transition, g_object_ref (priv->pan_page));
gtk_container_remove (GTK_CONTAINER (priv->stack), GTK_WIDGET (priv->pan_page));
}
IDE_TRACE_MSG ("Animating transition to %s column",
dest != self ? "another" : "same");
}
else
{
g_autoptr(IdePage) page = g_object_ref (priv->pan_page);
IDE_TRACE_MSG ("Moving page to a previously non-existant column");
gtk_container_remove (GTK_CONTAINER (priv->stack), GTK_WIDGET (page));
gtk_widget_show (GTK_WIDGET (page));
gtk_container_add (GTK_CONTAINER (dest_priv->stack), GTK_WIDGET (page));
}
cleanup:
g_clear_object (&priv->pan_theatric);
g_clear_object (&priv->pan_page);
gtk_widget_queue_draw (gtk_widget_get_toplevel (GTK_WIDGET (self)));
ide_frame_set_cursor (self, "arrow");
IDE_EXIT;
}
static gboolean
ide_frame_pan_begin (IdeFrame *self,
GdkEventSequence *sequence,
GtkGesturePan *gesture)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
GtkAllocation alloc;
cairo_surface_t *surface = NULL;
IdePage *page;
GdkWindow *window;
GtkWidget *grid;
cairo_t *cr;
gdouble x, y;
gboolean enable_animations;
IDE_ENTRY;
g_assert (IDE_IS_FRAME (self));
g_assert (GTK_IS_GESTURE_PAN (gesture));
g_assert (priv->pan_theatric == NULL);
page = ide_frame_get_visible_child (self);
if (page != NULL)
gtk_widget_get_allocation (GTK_WIDGET (page), &alloc);
g_object_get (gtk_settings_get_default (),
"gtk-enable-animations", &enable_animations,
NULL);
if (sequence != NULL ||
page == NULL ||
!enable_animations ||
is_uninitialized (&alloc) ||
NULL == (window = gtk_widget_get_window (GTK_WIDGET (page))) ||
NULL == (surface = gdk_window_create_similar_surface (window,
CAIRO_CONTENT_COLOR,
alloc.width,
alloc.height)))
{
if (sequence != NULL)
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
IDE_RETURN (FALSE);
}
gtk_gesture_drag_get_offset (GTK_GESTURE_DRAG (gesture), &x, &y);
cr = cairo_create (surface);
gtk_widget_draw (GTK_WIDGET (page), cr);
cairo_destroy (cr);
grid = gtk_widget_get_ancestor (GTK_WIDGET (self), IDE_TYPE_GRID);
gtk_widget_translate_coordinates (GTK_WIDGET (priv->top_stack), grid, 0, 0,
&alloc.x, &alloc.y);
priv->pan_page = g_object_ref (page);
priv->pan_theatric = g_object_new (DZL_TYPE_BOX_THEATRIC,
"surface", surface,
"target", grid,
"x", alloc.x + (gint)x,
"y", alloc.y,
"width", alloc.width,
"height", alloc.height,
NULL);
g_clear_pointer (&surface, cairo_surface_destroy);
/* Hide the page while we begin the possible transition to another
* layout stack.
*/
gtk_widget_hide (GTK_WIDGET (priv->pan_page));
/*
* Hide the mouse cursor until ide_frame_pan_end() is called.
* It can be distracting otherwise (and we want to warp it to the new
* grid column too).
*/
ide_frame_set_cursor (self, "none");
IDE_RETURN (TRUE);
}
void
_ide_frame_transfer (IdeFrame *self,
IdeFrame *dest,
IdePage *page)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
IdeFramePrivate *dest_priv = ide_frame_get_instance_private (dest);
const GdkRGBA *fg;
const GdkRGBA *bg;
g_return_if_fail (IDE_IS_FRAME (self));
g_return_if_fail (IDE_IS_FRAME (dest));
g_return_if_fail (IDE_IS_PAGE (page));
g_return_if_fail (GTK_WIDGET (priv->stack) == gtk_widget_get_parent (GTK_WIDGET (page)));
/*
* Inform the destination stack about our new primary colors so that it can
* begin a transition to the new colors. We also want to do this upfront so
* that we can reduce the amount of style invalidation caused during the
* transitions.
*/
fg = ide_page_get_primary_color_fg (page);
bg = ide_page_get_primary_color_bg (page);
_ide_frame_header_set_foreground_rgba (dest_priv->header, fg);
_ide_frame_header_set_background_rgba (dest_priv->header, bg);
/*
* If both the old and the new stacks are mapped, we can animate
* between them using a snapshot of the page. Well, we also need
* to be sure they have a valid allocation, but that check is done
* slightly after this because it makes things easier.
*/
if (gtk_widget_get_mapped (GTK_WIDGET (self)) &&
gtk_widget_get_mapped (GTK_WIDGET (dest)) &&
gtk_widget_get_mapped (GTK_WIDGET (page)))
{
GtkAllocation alloc, dest_alloc;
cairo_surface_t *surface = NULL;
GdkWindow *window;
GtkWidget *grid;
gboolean enable_animations;
grid = gtk_widget_get_ancestor (GTK_WIDGET (self), IDE_TYPE_GRID);
gtk_widget_get_allocation (GTK_WIDGET (page), &alloc);
gtk_widget_get_allocation (GTK_WIDGET (dest), &dest_alloc);
g_object_get (gtk_settings_get_default (),
"gtk-enable-animations", &enable_animations,
NULL);
if (enable_animations &&
grid != NULL &&
!is_uninitialized (&alloc) &&
!is_uninitialized (&dest_alloc) &&
dest_alloc.width > 0 && dest_alloc.height > 0 &&
NULL != (window = gtk_widget_get_window (GTK_WIDGET (page))) &&
NULL != (surface = gdk_window_create_similar_surface (window,
CAIRO_CONTENT_COLOR,
alloc.width,
alloc.height)))
{
DzlBoxTheatric *theatric = NULL;
AnimationState *state;
cairo_t *cr;
cr = cairo_create (surface);
gtk_widget_draw (GTK_WIDGET (page), cr);
cairo_destroy (cr);
gtk_widget_translate_coordinates (GTK_WIDGET (priv->stack), grid, 0, 0,
&alloc.x, &alloc.y);
gtk_widget_translate_coordinates (GTK_WIDGET (dest_priv->stack), grid, 0, 0,
&dest_alloc.x, &dest_alloc.y);
theatric = g_object_new (DZL_TYPE_BOX_THEATRIC,
"surface", surface,
"height", alloc.height,
"target", grid,
"width", alloc.width,
"x", alloc.x,
"y", alloc.y,
NULL);
state = g_slice_new0 (AnimationState);
state->source = g_object_ref (self);
state->dest = g_object_ref (dest);
state->page = g_object_ref (page);
state->theatric = theatric;
dzl_object_animate_full (theatric,
DZL_ANIMATION_EASE_IN_OUT_CUBIC,
TRANSITION_DURATION,
gtk_widget_get_frame_clock (GTK_WIDGET (self)),
animation_state_complete,
state,
"x", dest_alloc.x,
"width", dest_alloc.width,
"y", dest_alloc.y,
"height", dest_alloc.height,
NULL);
/*
* Mark the page as in-transition so that when we remove it
* we can ignore the items-changed until the animation completes.
*/
g_ptr_array_add (priv->in_transition, g_object_ref (page));
gtk_container_remove (GTK_CONTAINER (priv->stack), GTK_WIDGET (page));
cairo_surface_destroy (surface);
return;
}
}
g_object_ref (page);
gtk_container_remove (GTK_CONTAINER (priv->stack), GTK_WIDGET (page));
gtk_container_add (GTK_CONTAINER (dest_priv->stack), GTK_WIDGET (page));
g_object_unref (page);
}
