src/uielement.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * uielement.h
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007-2009 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #ifndef __MOON_UIELEMENT_H__
  15 #define __MOON_UIELEMENT_H__
  16
  17 #include <glib.h>
  18
  19 #include "dependencyobject.h"
  20 #include "resources.h"
  21 #include "point.h"
  22 #include "rect.h"
  23 #include "region.h"
  24 #include "list.h"
  25 #include "size.h"
  26 #include "layoutinformation.h"
  27
  28 #define QUANTUM_ALPHA 1
  29
  30 #if QUANTUM_ALPHA
  31 #define IS_TRANSLUCENT(x) (x * 255 < 254.5)
  32 #define IS_INVISIBLE(x) (x * 255 < .5)
  33 #else
  34 #define IS_TRANSLUCENT(x) (x < 1.0)
  35 #define IS_INVISIBLE(x) (x <= 0.0)
  36 #endif
  37
  38 class Surface;
  39
  40 /* @Namespace=System.Windows */
  41 class UIElement : public DependencyObject {
  42 public:
  43         UIElement ();
  44         virtual void Dispose ();
  45
  46         int dirty_flags;
  47         List::Node *up_dirty_node;
  48         List::Node *down_dirty_node;
  49
  50         bool force_invalidate_of_new_bounds;
  51         bool emitting_loaded;
  52
  53         Region *dirty_region;
  54
  55         int DumpHierarchy (UIElement *obj);
  56
  57         enum UIElementFlags {
  58                 IS_LOADED        = 0x01,
  59
  60                 // these two flags correspond to the 2 states of VisibilityProperty
  61                 RENDER_VISIBLE   = 0x02,
  62
  63                 // the HitTestVisible property
  64                 HIT_TEST_VISIBLE = 0x04,
  65
  66                 TOTAL_RENDER_VISIBLE   = 0x08,
  67                 TOTAL_HIT_TEST_VISIBLE = 0x10,
  68
  69                 SHAPE_EMPTY      = 0x20,        // there's is nothing to draw, the cached path may be NULL
  70                 SHAPE_NORMAL     = 0x40,        // normal drawing
  71                 SHAPE_DEGENERATE = 0x80,        // degenerate drawing, use the Stroke brush for filling
  72                 SHAPE_RADII      = 0x100,
  73                 SHAPE_MASK       = (SHAPE_EMPTY | SHAPE_NORMAL | SHAPE_DEGENERATE | SHAPE_RADII),
  74
  75                 // this means the element will be emitting OnLoaded
  76                 // shortly, and any child added to the element while
  77                 // it is in this state should post Loaded as well.
  78                 PENDING_LOADED   = 0x200
  79         };
  80
  81         virtual TimeManager *GetTimeManager ();
  82
  83         virtual bool PermitsMultipleParents () { return false; }
  84
  85         virtual void SetVisualParent (UIElement *visual_parent);
  86         /* @GenerateCBinding,GeneratePInvoke */
  87         UIElement *GetVisualParent () { return visual_parent; }
  88
  89         int GetVisualLevel () { return visual_level; }
  90         void SetVisualLevel (int level) { visual_level = level; }
  91
  92         /* @GenerateCBinding,GeneratePInvoke,ManagedAccess=Internal */
  93         virtual void SetSubtreeObject (DependencyObject *value);
  94
  95         /* @GenerateCBinding,GeneratePInvoke,ManagedAccess=Internal */
  96         virtual DependencyObject *GetSubtreeObject () { return subtree_object; }
  97
  98         /* @GenerateCBinding,GeneratePInvoke */
  99         virtual void ElementAdded (UIElement *obj);
 100         /* @GenerateCBinding,GeneratePInvoke */
 101         virtual void ElementRemoved (UIElement *obj);
 102
 103         virtual bool EnableAntiAlias() { return true; }
 104
 105         virtual void SetSurface (Surface *s);
 106
 107         // UpdateTotalRenderVisibility:
 108         //   Updates the opacity and render visibility on this item based on
 109         //   its parent's opacity and visibility as well as the value of its
 110         //   OpacityProperty and RenderVisibilityProperty.
 111         //
 112         void UpdateTotalRenderVisibility ();
 113         void ComputeTotalRenderVisibility ();
 114         bool GetActualTotalRenderVisibility ();
 115
 116         //
 117         // GetRenderVisible:
 118         //   Returns true if the Visibility property of this item is "Visible", and false otherwise
 119         //
 120         bool GetRenderVisible () { return (flags & UIElement::TOTAL_RENDER_VISIBLE) != 0; }
 121
 122
 123         // UpdateTotalHitTestVisibility:
 124         //   Updates the hit testability of the item based on the you know..
 125         //   The hit test flag.
 126         void UpdateTotalHitTestVisibility ();
 127         void ComputeTotalHitTestVisibility ();
 128         bool GetActualTotalHitTestVisibility ();
 129
 130         //
 131         // GetHitTestVisible:
 132         //   Returns true if the IsHitTestVisible property of this item true, and false otherwise
 133         //
 134         bool GetHitTestVisible () { return (flags & UIElement::TOTAL_HIT_TEST_VISIBLE) != 0; }
 135
 136         //
 137         // UpdateTransform:
 138         //   Updates the absolute_xform for this item
 139         //
 140         void UpdateTransform ();
 141         void ComputeLocalTransform ();
 142         void ComputeTransform ();
 143         virtual void TransformBounds (cairo_matrix_t *old, cairo_matrix_t *current);
 144
 145         //
 146         // IsLoaded:
 147         //   Returns true if the element has been attached to a
 148         //   surface and is part of the visual hierarchy.
 149         //
 150         bool IsLoaded () { return (flags & UIElement::IS_LOADED) != 0; }
 151         void ClearLoaded ();
 152
 153         //
 154         // Render:
 155         //   Renders the given @item on the @surface.  the area that is
 156         //   exposed is delimited by x, y, width, height
 157         //
 158         virtual void Render (cairo_t *cr, Region *region, bool path_only = false);
 159
 160         //
 161         // Paint:
 162         //   Do an optimized render pass on the this element and it's
 163         //   subtree.
 164         //
 165         void Paint (cairo_t *cr, Region *region, cairo_matrix_t *matrix);
 166
 167         // a non virtual method for use when we want to wrap render
 168         // with debugging and/or timing info
 169         void DoRender (cairo_t *cr, Region *region);
 170         bool UseBackToFront ();
 171
 172         //
 173         // GetSizeForBrush:
 174         //   Gets the size of the area to be painted by a Brush (needed for image/video scaling)
 175         virtual void GetSizeForBrush (cairo_t *cr, double *width, double *height);
 176
 177         //
 178         // GetOriginPoint:
 179         //   Gets real origin, required e.g. for lineargradientbrushes on Path
 180         virtual Point GetOriginPoint ()
 181         {
 182                 return Point (0.0, 0.0);
 183         }
 184
 185         //
 186         // ShiftPosition:
 187         //
 188         //   This method should actually set the x/y of the bounds
 189         //   rectangle to the new position.  It is virtual to allow
 190         //   subclasses with specialized bounds (Panel, InkPresenter)
 191         //   the opportunity to set those bounds' positions as well.
 192         //
 193         virtual void ShiftPosition (Point p);
 194
 195         //
 196         // UpdateBounds:
 197         //   Recomputes the bounds of this element, and if they're
 198         //   different chains up to its parent telling it to update
 199         //   its bounds.
 200         //
 201         void UpdateBounds (bool force_redraw_of_new_bounds = false);
 202         //
 203         // ComputeBounds:
 204         //   Updates the bounding box for the given item, this uses the parent
 205         //   chain to compute the composite affine.
 206         //
 207         // Output:
 208         //   item->bounds is updated
 209         //
 210         virtual void ComputeBounds ();
 211
 212         //
 213         // GetBounds:
 214         //   returns the current bounding box for the given item in surface
 215         //   coordinates.
 216         //
 217         Rect GetBounds () { return bounds; }
 218
 219         //
 220         // GetSubtreeBounds:
 221         //   returns the bounding box including all sub-uielements.
 222         //   implemented by containers in surface coordinates.
 223         //
 224         virtual Rect GetSubtreeBounds () { return bounds; }
 225
 226         //
 227         // GetRenderBounds:
 228         // returns the bounding box to be rendered, which
 229         // unfortunately isn't necessarily the same as either our
 230         // bounds or subtree bounds (in the case of inkpresenter)
 231         virtual Rect GetRenderBounds () { return bounds; }
 232
 233         //
 234         // GetCoverageBounds:
 235         // returns the bounding box in global coordinates that opaquely covered by this object
 236         //
 237         virtual Rect GetCoverageBounds () { return Rect (); }
 238
 239
 240         //
 241         // IsLayoutContainer:
 242         //   returns true if the container has children that require a measure
 243         //   pass.
 244         virtual bool IsLayoutContainer () { return GetSubtreeObject () != NULL; }
 245         virtual bool IsContainer () { return IsLayoutContainer (); }
 246
 247         // HitTest
 248
 249         //   Accumulate a list of all elements that will contain the
 250         //   point (or intersect the rectangle). The first node in the
 251         //   list is the most deeply nested node, the last node is the
 252         //   root.
 253         virtual void HitTest (cairo_t *cr, Point p, List *uielement_list);
 254         virtual void HitTest (cairo_t *cr, Rect r, List *uielement_list);
 255
 256         /* @GenerateCBinding,GeneratePInvoke */
 257         void FindElementsInHostCoordinates_p (Point p, HitTestCollection *uielement_list);
 258         /* @GenerateCBinding,GeneratePInvoke */
 259         void FindElementsInHostCoordinates_r (Rect p, HitTestCollection *uielement_list);
 260
 261         virtual bool CanFindElement () { return false; }
 262         virtual void FindElementsInHostCoordinates (cairo_t *cr, Point P, List *uielement_list);
 263         virtual void FindElementsInHostCoordinates (cairo_t *cr, Rect r, List *uielement_list);
 264
 265         //
 266         // Recomputes the bounding box, requests redraws,
 267         // the parameter determines if we should also update the transformation
 268         //
 269         void FullInvalidate (bool render_xform);
 270
 271         //
 272         // InsideObject:
 273         //   Returns whether the position x, y is inside the object
 274         //
 275         virtual bool InsideObject (cairo_t *cr, double x, double y);
 276
 277         //
 278         // Checks if the point is inside the Clip region.
 279         // Returns true if no Clip region is defined
 280         // (which is actually an infinitely big Clip region).
 281         //
 282         bool InsideClip (cairo_t *cr, double x, double y);
 283
 284         //
 285         // Invalidates a subrectangle of this element
 286         //
 287         void Invalidate (Rect r);
 288
 289         //
 290         // Invalidates a subregion of this element
 291         void Invalidate (Region *region);
 292
 293         //
 294         // Invalidates the entire bounding rectangle of this element
 295         //
 296         /* @GenerateCBinding */
 297         void Invalidate ();
 298
 299         //
 300         // Invalidates the paint region of the element and its subtree
 301         //
 302         void InvalidateSubtreePaint ();
 303         void InvalidateMask ();
 304         void InvalidateClip ();
 305         void InvalidateVisibility ();
 306
 307         //
 308         // GetTransformOrigin:
 309         //   Returns the transformation origin based on  of the item and the
 310         //   xform_origin
 311         virtual Point GetTransformOrigin () {
 312                 return Point (0, 0);
 313         }
 314
 315         //
 316         // EmitKeyDown:
 317         //
 318         bool EmitKeyDown (GdkEventKey *key);
 319
 320         //
 321         // EmitKeyUp:
 322         //
 323         bool EmitKeyUp (GdkEventKey *key);
 324
 325         //
 326         // EmitGotFocus:
 327         //   Invoked when the mouse focuses the given object
 328         //
 329         bool EmitGotFocus ();
 330
 331         //
 332         // EmitLostFocus:
 333         //   Invoked when the given object loses mouse focus
 334         //
 335         bool EmitLostFocus ();
 336
 337         //
 338         // EmitLostMouseCapture:
 339         //   Invoked when the given object loses mouse capture
 340         //
 341         bool EmitLostMouseCapture ();
 342
 343         //
 344         // CaptureMouse:
 345         //
 346         //    Attempts to capture the mouse.  If successful, all mouse
 347         //    events will be transmitted directly to this element.
 348         //    Leave/Enter events will no longer be sent.
 349         //
 350         /* @GenerateCBinding,GeneratePInvoke,GenerateJSBinding */
 351         bool CaptureMouse ();
 352         virtual bool CanCaptureMouse () { return true; }
 353
 354         /* @GenerateCBinding,GeneratePInvoke */
 355         virtual bool Focus (bool recurse = true);
 356
 357         //
 358         // ReleaseMouseCapture:
 359         //
 360         //    Attempts to release the mouse.  If successful, any
 361         //    applicable Leave/Enter events for the current mouse
 362         //    position will be sent.
 363         //
 364         /* @GenerateCBinding,GeneratePInvoke,GenerateJSBinding */
 365         void ReleaseMouseCapture ();
 366
 367         List* WalkTreeForLoaded (bool *delay);
 368
 369         void PostSubtreeLoad (List *load_list);
 370         static void EmitSubtreeLoad (List *load_list);
 371         static void emit_delayed_loaded (EventObject *data);
 372
 373         virtual void OnLoaded ();
 374
 375         virtual void OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error);
 376         virtual void OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args);
 377         virtual void OnCollectionChanged (Collection *col, CollectionChangedEventArgs *args);
 378
 379         //
 380         // CacheInvalidateHint:
 381         //   Give a hint to this UIElement that it should free any possible
 382         //   cached (mem-intensive) data it has. This ie. can happen when the
 383         //   element is removed from a collection, becomes invisible, etc.
 384         //
 385         virtual void CacheInvalidateHint ();
 386
 387         //
 388         // 2.0 methods
 389         //
 390
 391         // Layout foo
 392
 393         void DoMeasure ();
 394         void DoArrange ();
 395
 396         /* @GenerateCBinding,GeneratePInvoke */
 397         virtual void Measure (Size availableSize) = 0;
 398         /* @GenerateCBinding,GeneratePInvoke */
 399         virtual void Arrange (Rect finalRect) = 0;
 400         /* @GenerateCBinding,GeneratePInvoke */
 401         void InvalidateMeasure ();
 402         /* @GenerateCBinding,GeneratePInvoke */
 403         void InvalidateArrange ();
 404         /* @GenerateCBinding,GeneratePInvoke,GenerateJSBinding */
 405         virtual void UpdateLayout () = 0;
 406
 407         /* @GenerateCBinding,GeneratePInvoke */
 408         Size GetDesiredSize () { return desired_size; }
 409
 410         /* @GenerateCBinding,GeneratePInvoke */
 411         Size GetRenderSize () { return render_size; }
 412
 413         /* @GenerateCBinding,GeneratePInvoke,GenerateJSBinding=TransformToVisual,Version=2.0 */
 414         GeneralTransform *GetTransformToUIElementWithError (UIElement *to_element, MoonError *error);
 415
 416         //
 417         // TransformPoint:
 418         //
 419         // Maps the point to the coordinate space of this item
 420         //
 421         void TransformPoint (double *x, double *y);
 422
 423         /* @PropertyType=Geometry,GenerateAccessors */
 424         const static int ClipProperty;
 425         /* @PropertyType=bool,DefaultValue=true,GenerateAccessors */
 426         const static int IsHitTestVisibleProperty;
 427         /* @PropertyType=Brush,GenerateAccessors */
 428         const static int OpacityMaskProperty;
 429         /* @PropertyType=double,DefaultValue=1.0,GenerateAccessors */
 430         const static int OpacityProperty;
 431         /* @PropertyType=Point,DefaultValue=Point (0\,0),GenerateAccessors */
 432         const static int RenderTransformOriginProperty;
 433         /* @PropertyType=Transform,GenerateAccessors,GenerateManagedAccessors=false */
 434         const static int RenderTransformProperty;
 435         /* @PropertyType=Visibility,DefaultValue=VisibilityVisible,GenerateAccessors */
 436         const static int VisibilityProperty;
 437         /* @PropertyType=bool,DefaultValue=true,GenerateAccessors */
 438         const static int UseLayoutRoundingProperty;
 439
 440         // in 2.0 these properties are actually in FrameworkElement
 441         /* @PropertyType=MouseCursor,DefaultValue=MouseCursorDefault,ManagedDeclaringType=FrameworkElement,ManagedPropertyType=Cursor,ManagedFieldAccess=Internal,GenerateAccessors,Validator=CursorValidator */
 442         const static int CursorProperty;
 443         /* @PropertyType=ResourceDictionary,ManagedDeclaringType=FrameworkElement,AutoCreateValue,ManagedFieldAccess=Internal,ManagedSetterAccess=Internal,GenerateAccessors */
 444         const static int ResourcesProperty;
 445         /* @PropertyType=object,ManagedDeclaringType=FrameworkElement,ManagedPropertyType=object,IsCustom=true */
 446         const static int TagProperty;
 447         /* @PropertyType=TriggerCollection,ManagedDeclaringType=FrameworkElement,AutoCreateValue,ManagedFieldAccess=Internal,ManagedSetterAccess=Internal,GenerateAccessors */
 448         const static int TriggersProperty;
 449
 450         //
 451         // Property Accessors
 452
 453         //
 454         void SetClip (Geometry *clip);
 455         Geometry *GetClip ();
 456
 457         MouseCursor GetCursor ();
 458         void SetCursor (MouseCursor value);
 459
 460         void SetIsHitTestVisible (bool visible);
 461         bool GetIsHitTestVisible ();
 462
 463         void SetOpacityMask (Brush *mask);
 464         Brush *GetOpacityMask ();
 465
 466         void SetOpacity (double opacity);
 467         double GetOpacity ();
 468
 469         void SetRenderTransform (Transform *transform);
 470         Transform *GetRenderTransform ();
 471
 472         void SetRenderTransformOrigin (Point *origin);
 473         Point *GetRenderTransformOrigin ();
 474
 475         ResourceDictionary* GetResources();
 476         void SetResources (ResourceDictionary *value);
 477
 478         TriggerCollection *GetTriggers ();
 479         void SetTriggers (TriggerCollection* value);
 480
 481         Visibility GetVisibility ();
 482         void SetVisibility (Visibility value);
 483
 484         bool GetUseLayoutRounding ();
 485         void SetUseLayoutRounding (bool value);
 486
 487         // Events you can AddHandler to
 488
 489         /* @ManagedDeclaringType=FrameworkElement,DelegateType=RoutedEventHandler */
 490         const static int LoadedEvent;
 491         /* @GenerateManagedEvent=false */
 492         const static int UnloadedEvent;
 493         /* @DelegateType=MouseEventHandler */
 494         const static int MouseMoveEvent;
 495         /* @DelegateType=MouseButtonEventHandler */
 496         const static int MouseLeftButtonDownEvent;
 497         /* @DelegateType=MouseButtonEventHandler */
 498         const static int MouseLeftButtonUpEvent;
 499         /* @DelegateType=KeyEventHandler */
 500         const static int KeyDownEvent;
 501         /* @DelegateType=KeyEventHandler */
 502         const static int KeyUpEvent;
 503         /* @DelegateType=MouseEventHandler */
 504         const static int MouseEnterEvent;
 505         /* @DelegateType=MouseEventHandler */
 506         const static int MouseLeaveEvent;
 507         /* @GenerateManagedEvent=false */
 508         const static int InvalidatedEvent;
 509         /* @DelegateType=RoutedEventHandler */
 510         const static int GotFocusEvent;
 511         /* @DelegateType=RoutedEventHandler */
 512         const static int LostFocusEvent;
 513         /* @DelegateType=MouseEventHandler */
 514         const static int LostMouseCaptureEvent;
 515
 516         // these we turn off generation for and handle manually since
 517         // they're desktop-only
 518
 519         /* @GenerateManagedEvent=false */
 520         const static int MouseLeftButtonMultiClickEvent;
 521         /* @GenerateManagedEvent=false */
 522         const static int MouseRightButtonDownEvent;
 523         /* @GenerateManagedEvent=false */
 524         const static int MouseRightButtonUpEvent;
 525         /* @GenerateManagedEvent=false */
 526         const static int MouseWheelEvent;
 527
 528         // Helper method which checks recursively checks this element and its visual
 529         // parents to see if any are loaded.
 530         static bool IsSubtreeLoaded (UIElement *element);
 531
 532 protected:
 533         virtual ~UIElement ();
 534         Rect IntersectBoundsWithClipPath (Rect bounds, bool transform);
 535         void RenderClipPath (cairo_t *cr, bool path_only = false);
 536
 537         void SetDesiredSize (Size s) { desired_size = s; }
 538         void SetRenderSize (Size s) { render_size = s; }
 539
 540         // The computed bounding box
 541         Rect bounds;
 542         Rect extents;
 543
 544         int flags;
 545
 546         // Absolute affine transform, precomputed with all of its data
 547         cairo_matrix_t absolute_xform;
 548         cairo_matrix_t layout_xform;
 549
 550         void FrontToBack (Region *surface_region, List *render_list);
 551         virtual void PreRender (cairo_t *cr, Region *region, bool front_to_back);
 552         virtual void PostRender (cairo_t *cr, Region *region, bool front_to_back);
 553
 554         static void CallPreRender (cairo_t *cr, UIElement *element, Region *region, bool front_to_back);
 555         static void CallPostRender (cairo_t *cr, UIElement *element, Region *region, bool front_to_back);
 556
 557 private:
 558         int visual_level;
 559         UIElement *visual_parent;
 560         DependencyObject *subtree_object;
 561         double total_opacity;
 562         Brush *opacityMask;
 563         Size desired_size;
 564         Size render_size;
 565
 566         // The local render transform including tranform origin
 567         cairo_matrix_t local_xform;
 568 };
 569
 570 #endif /* __MOON_UIELEMENT_H__ */