src/control.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * control.cpp:
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #include <config.h>
  15
  16 #include "rect.h"
  17 #include "runtime.h"
  18 #include "control.h"
  19 #include "canvas.h"
  20 #include "namescope.h"
  21 #include "application.h"
  22 #include "geometry.h"
  23 #include "tabnavigationwalker.h"
  24 #include "deployment.h"
  25
  26 Control::Control ()
  27 {
  28         SetObjectType (Type::CONTROL);
  29
  30         enabled_local = true;
  31         enabled_parent = true;
  32         template_root = NULL;
  33 }
  34
  35 Control::~Control ()
  36 {
  37 }
  38
  39 void
  40 Control::FindElementsInHostCoordinates (cairo_t *cr, Point p, List *uielement_list)
  41 {
  42         if (GetIsEnabled ())
  43                 FrameworkElement::FindElementsInHostCoordinates (cr, p, uielement_list);
  44 }
  45
  46 void
  47 Control::HitTest (cairo_t *cr, Point p, List *uielement_list)
  48 {
  49         if (GetIsEnabled ())
  50                 FrameworkElement::HitTest (cr, p, uielement_list);
  51 }
  52
  53 bool
  54 Control::InsideObject (cairo_t *cr, double x, double y)
  55 {
  56         /*
  57          * Controls don't get hit themselves the rendered elements
  58          * do and it bubbles up
  59          */
  60         return false;
  61 }
  62
  63 void
  64 Control::OnLoaded ()
  65 {
  66         Types *types = Deployment::GetCurrent ()->GetTypes ();
  67         UIElement *e = GetVisualParent ();
  68         while (e && !types->IsSubclassOf (e->GetObjectType (), Type::CONTROL))
  69                 e = e->GetVisualParent ();
  70         if (e)
  71                 ((Control *)e)->UpdateEnabled ();
  72
  73         FrameworkElement::OnLoaded ();
  74 }
  75
  76 void
  77 Control::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
  78 {
  79         if (args->GetProperty ()->GetOwnerType() != Type::CONTROL) {
  80                 FrameworkElement::OnPropertyChanged (args, error);
  81                 return;
  82         }
  83
  84         if (args->GetId () == Control::TemplateProperty) {
  85                 if (GetSubtreeObject ())
  86                         ElementRemoved ((UIElement *) GetSubtreeObject ());
  87         }
  88         else if (args->GetId () == Control::PaddingProperty
  89                  || args->GetId () == Control::BorderThicknessProperty) {
  90                 InvalidateMeasure ();
  91         } else if (args->GetId () == Control::IsEnabledProperty) {
  92                 if (!args->GetNewValue ()->AsBool ()) {
  93                         Surface *surface = Deployment::GetCurrent ()->GetSurface ();
  94                         if (surface && surface->GetFocusedElement () == this) {
  95                                 // Ensure this element loses focus, then try to focus the next suitable element
  96                                 surface->FocusElement (NULL);
  97                                 TabNavigationWalker::Focus (this, true);
  98                         }
  99                         ReleaseMouseCapture ();
 100                 }
 101                 args->ref (); // to counter the unref in Emit
 102                 Emit (IsEnabledChangedEvent, args);
 103         } else if (args->GetId () == Control::HorizontalContentAlignmentProperty
 104                    || args->GetId () == Control::VerticalContentAlignmentProperty) {
 105                 InvalidateArrange ();
 106         }
 107         NotifyListenersOfPropertyChange (args, error);
 108 }
 109
 110 void
 111 Control::SetVisualParent (UIElement *visual_parent)
 112 {
 113         FrameworkElement::SetVisualParent (visual_parent);
 114         if (!UIElement::IsSubtreeLoaded (this))
 115                 return;
 116
 117         this->enabled_parent = GetParentEnabledState (this);
 118         SetValue (Control::IsEnabledProperty, Value (enabled_local));
 119 }
 120
 121 bool
 122 Control::GetParentEnabledState (UIElement *element)
 123 {
 124         do {
 125                 element = element->GetVisualParent ();
 126         } while (element && !element->Is (Type::CONTROL));
 127
 128         return element ? ((Control *) element)->GetIsEnabled () : true;
 129 }
 130
 131 bool
 132 Control::SetValueWithErrorImpl (DependencyProperty *property, Value *value, MoonError *error)
 133 {
 134         if (property->GetId () == Control::IsEnabledProperty) {
 135                 this->enabled_local = value->AsBool ();
 136                 if ((enabled_local && enabled_parent) == GetIsEnabled ())
 137                         return true;
 138
 139                 Value v (enabled_local && (enabled_parent));
 140
 141                 // If we don't propagate the changes down the tree here, the EnabledChanged events
 142                 // from the subtree are raised in the wrong order
 143                 bool b = FrameworkElement::SetValueWithErrorImpl (property, &v, error);
 144                 if (b)
 145                         UpdateEnabled ();
 146                 return  b;
 147         }
 148         return FrameworkElement::SetValueWithErrorImpl (property, value, error);
 149 }
 150
 151 bool
 152 Control::DoApplyTemplate ()
 153 {
 154         ControlTemplate *t = GetTemplate ();
 155         if (!t)
 156                 return FrameworkElement::DoApplyTemplate ();
 157
 158         // If the template expands to an element which is *not* a UIElement
 159         // we don't apply the template.
 160         DependencyObject *root = t->GetVisualTree (this);
 161         if (root && !root->Is (Type::UIELEMENT)) {
 162                 g_warning ("Control::DoApplyTemplate () Template root was not a UIElement");
 163                 root->unref ();
 164                 root = NULL;
 165         }
 166
 167         if (!root)
 168                 return FrameworkElement::DoApplyTemplate ();
 169
 170         // No need to ref template_root here as ElementAdded refs it
 171         // and it is cleared when ElementRemoved is called.
 172         template_root = (UIElement *)root;
 173         ElementAdded (template_root);
 174
 175         if (GetSurface()) {
 176                 bool post = false;
 177
 178                 ((UIElement*)root)->WalkTreeForLoadedHandlers (&post, true, true);
 179
 180                 if (post)
 181                         Deployment::GetCurrent()->PostLoaded ();
 182         }
 183
 184         return true;
 185 }
 186
 187 void
 188 Control::ElementAdded (UIElement *item)
 189 {
 190         MoonError e;
 191         item->SetParent (this, &e);
 192         SetSubtreeObject (item);
 193         FrameworkElement::ElementAdded (item);
 194 }
 195
 196 void
 197 Control::ElementRemoved (UIElement *item)
 198 {
 199         template_root = NULL;
 200         MoonError e;
 201         item->SetParent (NULL, &e);
 202         FrameworkElement::ElementRemoved (item);
 203 }
 204
 205 DependencyObject *
 206 Control::GetTemplateChild (const char *name)
 207 {
 208         if (template_root)
 209                 return template_root->FindName (name);
 210
 211         return NULL;
 212 }
 213
 214 bool
 215 Control::Focus (bool recurse)
 216 {
 217         Surface *surface = GetSurface ();
 218         if (!surface)
 219                 return false;
 220
 221          /* according to msdn, these three things must be true for an element to be focusable:
 222          *
 223          * 1. the element must be visible
 224          * 2. the element must have IsTabStop = true
 225          * 3. the element must be part of the plugin's visual tree, and must have had its Loaded event fired.
 226          */
 227
 228          /*
 229          * If the current control is not focusable, we walk the visual tree and stop as soon
 230          * as we find the first focusable child. That then becomes focused
 231          */
 232         Types *types = Deployment::GetCurrent ()->GetTypes ();
 233         DeepTreeWalker walker (this);
 234         while (UIElement *e = walker.Step ()) {
 235                 if (!types->IsSubclassOf (e->GetObjectType (), Type::CONTROL))
 236                         continue;
 237
 238                 Control *c = (Control *)e;
 239                 if (!c->GetIsEnabled ()) {
 240                         if (!recurse)
 241                                 return false;
 242
 243                         walker.SkipBranch ();
 244                         continue;
 245                 }
 246
 247                 // A control is focusable if it is attached to a visual tree whose root
 248                 // element has been loaded
 249                 bool loaded = false;
 250                 for (UIElement *check = this; !loaded && check != NULL; check = check->GetVisualParent ())
 251                         loaded |= check->IsLoaded ();
 252
 253                 if (loaded && c->GetRenderVisible () && c->GetIsTabStop ())
 254                         return surface->FocusElement (c);
 255
 256                 if (!recurse)
 257                         return false;
 258         }
 259         return false;
 260 }
 261
 262 void
 263 Control::UpdateEnabled ()
 264 {
 265         Types *types = Deployment::GetCurrent ()->GetTypes ();
 266         DeepTreeWalker walker = DeepTreeWalker (this);
 267         while (UIElement *child = walker.Step ()) {
 268                 if (child == this || !types->IsSubclassOf (child->GetObjectType (), Type::CONTROL))
 269                         continue;
 270
 271                 Control *control = (Control *)child;
 272                 control->enabled_parent = (enabled_local && enabled_parent);
 273                 control->SetValue (Control::IsEnabledProperty, Value (control->enabled_local));
 274                 walker.SkipBranch ();
 275         }
 276 }