sub_arctic.lib
Class shadow_caster

java.lang.Object
  |
  +--sub_arctic.lib.min_interactor
        |
        +--sub_arctic.lib.base_interactor
              |
              +--sub_arctic.lib.base_parent_interactor
                    |
                    +--sub_arctic.lib.shadow_caster

public class shadow_caster
extends base_parent_interactor

This class provides a container that draws its child subtrees with a shadow under them. This is done by drawing the children twice, once with a shadow_drawable object (which turns all colors gray and offsets the drawing slightly), then again on top normally. Shadow_graphics objects have two drawing settings, expensive but accurate, and fast but inaccurate (in particular drawing all images as filled rectangles). This setting can also be made here and defaults to fast.

See Also:
shadow_drawable

Field Summary
protected  boolean _expensive_draw
          Do we do expensive but realistic drawing of shadows for images, or do we just do their bounding rectangle? Default is to be cheap about it.
protected  int _x_offset
          X offset for shadow
protected  int _y_offset
          Y offset for shadow
 
Fields inherited from class sub_arctic.lib.base_interactor
_child_index, _child_list, _clip_bounds, _constraint_flags, _enabled_constraint, _flags, _h, _h_constraint, _parent, _part_a_constraint, _part_b_constraint, _user_data, _visible_constraint, _w, _w_constraint, _x, _x_constraint, _y, _y_constraint, default_child_hint
 
Constructor Summary
shadow_caster(int xv, int yv, int wv, int hv)
          Constructor with default shadow offsets.
shadow_caster(int xv, int yv, int wv, int hv, int shad_x, int shad_y)
          Full constructor.
 
Method Summary
 void damage_from_child(interactor originator, java.lang.Object user_info, java.awt.Point top_left, java.awt.Dimension sz)
          Catch damage from our children and make it bigger to account for the shadow.
protected  void draw_self_local(drawable d)
          Draw self.
 boolean expensive_draw()
          Are currently doing expensive but realistic drawing shadows for images, or do are we just drawing their bounding rectangle?
 void set_expensive_draw(boolean v)
          Set whether we draw image shadows realistically, but expensively (slow), or just draw their bounding rectangles (fast).
 void set_offset(int xoff, int yoff)
          Set offset for shadow.
 void set_x_offset(int xoff)
          Set x offset for shadow.
 void set_y_offset(int yoff)
          Set y offset for shadow.
 int x_offset()
          X offset for shadow.
 int y_offset()
          Y offset for shadow.
 
Methods inherited from class sub_arctic.lib.base_interactor
active_constraints, add_child, add_user_datum, attach_dependent, bound, callback_obj, child_index, child, clear_child_list, clear_constraint_flag_bit, clear_flag_bit, configure, constraint_flag_is_set, constraint_flag_string, constraint_on, custom_fun1, custom_fun2, damage_fixed, damage_self, damage_self, damage_self, damage_self, damage_self, detach_dependent, do_action, do_action, do_callback, do_callback, drag_feature_point, draw_children, draw_self, enabled_constraint, enabled, enter_local_coordinates, eval_enabled, eval_h, eval_part_a, eval_part_b, eval_visible, eval_w, eval_x, eval_y, eval, exit_local_coords, feature_point_enabled, feature_point, filter_pt, find_child, first_callback_num, fixed_children, flag_is_set, flag_string, focus_set_enter, focus_set_exit, get_awt_component, get_external_constraint, get_part, get_top_level, get_value, global_to_local, global_to_local, h_constraint, h, handle_cycle, inform_ood, insert_child, inside_bounds, into_local, into_local, into_parent, into_parent, intrinsic_constraints, is_constrained, last_callback_num, local_to_global, local_to_global, mark_all_ood, mark_enabled_ood, mark_h_ood, mark_ood, mark_part_a_ood, mark_part_b_ood, mark_reparented_ood, mark_visible_ood, mark_w_ood, mark_x_ood, mark_y_ood, marked_ood, move_child_downward, move_child_downward, move_child_to_bottom, move_child_to_bottom, move_child_to_top, move_child_to_top, move_child_upward, move_child_upward, move_downward, move_to_bottom, move_to_top, move_upward, new_look_configure, next_sibling, num_actions, num_children, num_feature_points, ood_inform_all, parent, part_a_constraint, part_a, part_b_constraint, part_b, pick_within_children, pick, picked_by, pos, prev_sibling, register_resource_names, remove_child, remove_child, remove_user_datum, restyle_look_resources, restyle, set_callback_obj, set_child_index, set_child, set_constraint_flag_bit, set_constraint_flag_bit, set_constraint, set_constraint, set_enabled_constraint, set_enabled_constraint, set_enabled_constraint, set_enabled, set_flag_bit, set_flag_bit, set_h_constraint, set_h_constraint, set_h_constraint, set_h, set_intrinsic_h, set_intrinsic_size, set_intrinsic_w, set_parent, set_part_a_constraint, set_part_a_constraint, set_part_a_constraint, set_part_a, set_part_b_constraint, set_part_b_constraint, set_part_b_constraint, set_part_b, set_pos, set_pos, set_raw_enabled, set_raw_h, set_raw_part_a, set_raw_part_b, set_raw_visible, set_raw_w, set_raw_x, set_raw_y, set_size, set_style_lock, set_user_info, set_visible_constraint, set_visible_constraint, set_visible_constraint, set_visible, set_w_constraint, set_w_constraint, set_w_constraint, set_w, set_x_constraint, set_x_constraint, set_x_constraint, set_x, set_y_constraint, set_y_constraint, set_y_constraint, set_y, setup_for_children, setup_for_children, setup_for_fixed_children, size, style_change_local, style_change, supports_children, tag_str, toString, traverse_and_collect_children, traverse_and_collect_parent, traverse_and_collect, trivial_reject, trivial_reject, user_data, user_info, value_ood, visible_constraint, visible, w_constraint, w, x_constraint, x_into_local, x_into_parent, x, y_constraint, y_into_local, y_into_parent, y
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Field Detail

_expensive_draw

protected boolean _expensive_draw
Do we do expensive but realistic drawing of shadows for images, or do we just do their bounding rectangle? Default is to be cheap about it.

_x_offset

protected int _x_offset
X offset for shadow

_y_offset

protected int _y_offset
Y offset for shadow
Constructor Detail

shadow_caster

public shadow_caster(int xv,
                     int yv,
                     int wv,
                     int hv,
                     int shad_x,
                     int shad_y)
Full constructor.
Parameters:
int - xv the x position of the interactor.
int - yv the y position of the interactor.
int - wv the width of the interactor.
int - hv the height of the interactor.
int - shad_x the x offset of the shadow.
int - shad_y the y offset of the shadow.

shadow_caster

public shadow_caster(int xv,
                     int yv,
                     int wv,
                     int hv)
Constructor with default shadow offsets.
Parameters:
int - xv the x position of the interactor.
int - yv the y position of the interactor.
int - wv the width of the interactor.
int - hv the height of the interactor.
Method Detail

expensive_draw

public boolean expensive_draw()
Are currently doing expensive but realistic drawing shadows for images, or do are we just drawing their bounding rectangle?
Returns:
boolean true if we are doing expensive drawing.

set_expensive_draw

public void set_expensive_draw(boolean v)
Set whether we draw image shadows realistically, but expensively (slow), or just draw their bounding rectangles (fast).
Parameters:
boolean - v the new setting (true for expensive).

x_offset

public int x_offset()
X offset for shadow.
Returns:
int the x offset of the shadow.

set_x_offset

public void set_x_offset(int xoff)
Set x offset for shadow.
Parameters:
int - xoff new x offset.

y_offset

public int y_offset()
Y offset for shadow.
Returns:
int the y offset of the shadow.

set_y_offset

public void set_y_offset(int yoff)
Set y offset for shadow.
Parameters:
int - yoff new y offset.

set_offset

public void set_offset(int xoff,
                       int yoff)
Set offset for shadow.
Parameters:
int - xoff new x offset.
int - yoff new y offset.

draw_self_local

protected void draw_self_local(drawable d)
Draw self. We draw our children twice, once in shadow offset by a small translation, then again in normal colors.
Parameters:
drawable - d the surface we draw on.
Overrides:
draw_self_local in class base_interactor

damage_from_child

public void damage_from_child(interactor originator,
                              java.lang.Object user_info,
                              java.awt.Point top_left,
                              java.awt.Dimension sz)
Catch damage from our children and make it bigger to account for the shadow.
Parameters:
interactor - originator the interactor that caused the damage.
Object - user_info uninterpreted information supplied by the originator at damage time.
Point - top_left top-left corner of child's damage area (in our coordinate system).
Dimension - sz size of the damage area.
Overrides:
damage_from_child in class base_interactor