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
  25 Control::Control ()
  26 {
  27         SetObjectType (Type::CONTROL);
  28
  29         applied_template = NULL;
  30         enabled_local = true;
  31         enabled_parent = true;
  32         template_root = NULL;
  33 }
  34
  35 Control::~Control ()
  36 {
  37 }
  38
  39 void
  40 Control::Dispose ()
  41 {
  42         if (applied_template) {
  43                 applied_template->unref();
  44                 applied_template = NULL;
  45         }
  46
  47         if (template_root) {
  48                 template_root->unref ();
  49                 template_root = NULL;
  50         }
  51
  52         FrameworkElement::Dispose ();
  53 }
  54
  55 void
  56 Control::FindElementsInHostCoordinates (cairo_t *cr, Point p, List *uielement_list)
  57 {
  58         if (GetIsEnabled ())
  59                 FrameworkElement::FindElementsInHostCoordinates (cr, p, uielement_list);
  60 }
  61
  62 void
  63 Control::HitTest (cairo_t *cr, Point p, List *uielement_list)
  64 {
  65         if (GetIsEnabled ())
  66                 FrameworkElement::HitTest (cr, p, uielement_list);
  67 }
  68
  69 bool
  70 Control::InsideObject (cairo_t *cr, double x, double y)
  71 {
  72         /*
  73          * Controls don't get hit themselves the rendered elements
  74          * do and it bubbles up
  75          */
  76         return false;
  77 }
  78
  79 void
  80 Control::OnLoaded ()
  81 {
  82         Types *types = Deployment::GetCurrent ()->GetTypes ();
  83         UIElement *e = GetVisualParent ();
  84         while (e && !types->IsSubclassOf (e->GetObjectType (), Type::CONTROL))
  85                 e = e->GetVisualParent ();
  86         if (e)
  87                 ((Control *)e)->UpdateEnabled ();
  88
  89         FrameworkElement::OnLoaded ();
  90 }
  91
  92 void
  93 Control::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
  94 {
  95         if (args->GetProperty ()->GetOwnerType() != Type::CONTROL) {
  96                 FrameworkElement::OnPropertyChanged (args, error);
  97                 return;
  98         }
  99
 100         if (args->GetId () == Control::TemplateProperty) {
 101                 if (IsLoaded())
 102                         ApplyTemplate ();
 103                 InvalidateMeasure ();
 104         }
 105         else if (args->GetId () == Control::PaddingProperty
 106                  || args->GetId () == Control::BorderThicknessProperty) {
 107                 InvalidateMeasure ();
 108         } else if (args->GetId () == Control::IsEnabledProperty) {
 109                 if (!args->GetNewValue ()->AsBool ()) {
 110                         Surface *surface = Deployment::GetCurrent ()->GetSurface ();
 111                         if (surface && surface->GetFocusedElement () == this) {
 112                                 // Ensure this element loses focus, then try to focus the next suitable element
 113                                 surface->FocusElement (NULL);
 114                                 TabNavigationWalker::Focus (this, true);
 115                         }
 116                         ReleaseMouseCapture ();
 117                 }
 118                 Emit (IsEnabledChangedEvent);
 119         } else if (args->GetId () == Control::HorizontalContentAlignmentProperty
 120                    || args->GetId () == Control::VerticalContentAlignmentProperty) {
 121                 InvalidateArrange ();
 122         }
 123         NotifyListenersOfPropertyChange (args, error);
 124 }
 125
 126 void
 127 Control::SetVisualParent (UIElement *visual_parent)
 128 {
 129         FrameworkElement::SetVisualParent (visual_parent);
 130         if (!UIElement::IsSubtreeLoaded (this))
 131                 return;
 132
 133         Types *types = Deployment::GetCurrent ()->GetTypes ();
 134         if (!visual_parent) {
 135                 enabled_parent = true;
 136         } else {
 137                 UIElement *parent = GetVisualParent ();
 138                 while (parent) {
 139                         if (!types->IsSubclassOf (parent->GetObjectType (), Type::CONTROL)) {
 140                                 parent = parent->GetVisualParent ();
 141                         }
 142                         else {
 143                                 this->enabled_parent = ((Control *)parent)->GetIsEnabled ();
 144                                 break;
 145                         }
 146                 }
 147         }
 148         SetValue (Control::IsEnabledProperty, Value (enabled_local));
 149 }
 150
 151 bool
 152 Control::SetValueWithErrorImpl (DependencyProperty *property, Value *value, MoonError *error)
 153 {
 154         if (property->GetId () == Control::IsEnabledProperty) {
 155                 this->enabled_local = value->AsBool ();
 156                 if ((enabled_local && enabled_parent) == GetIsEnabled ())
 157                         return true;
 158
 159                 Value v (enabled_local && (enabled_parent));
 160
 161                 // If we don't propagate the changes down the tree here, the EnabledChanged events
 162                 // from the subtree are raised in the wrong order
 163                 bool b = FrameworkElement::SetValueWithErrorImpl (property, &v, error);
 164                 if (b)
 165                         UpdateEnabled ();
 166                 return  b;
 167         }
 168         return FrameworkElement::SetValueWithErrorImpl (property, value, error);
 169 }
 170
 171 bool
 172 Control::ApplyTemplate ()
 173 {
 174         return ApplyTemplate (GetTemplate ()) == TemplateStatusApplied;
 175 }
 176
 177 TemplateStatus
 178 Control::ApplyTemplate (FrameworkTemplate *t)
 179 {
 180         // If the template is null, we won't apply it
 181         if (!t)
 182                 return TemplateStatusNotApplied;
 183
 184         if (applied_template == t)
 185                 return TemplateStatusAlreadyApplied;
 186
 187         ClearTemplate ();
 188
 189         applied_template = t;
 190         applied_template->ref();
 191
 192         // If the template expands to an element which is *not* a UIElement
 193         // we don't apply the template.
 194         DependencyObject *root = applied_template->GetVisualTree (this);
 195         if (root && !root->Is (Type::UIELEMENT)) {
 196                 g_warning ("Control::ApplyTemplate (FrameworkTemplate*) Template root was not a UIElement");
 197                 root->unref ();
 198                 return TemplateStatusNotApplied;
 199         }
 200         return ApplyTemplateRoot ((UIElement *) root);
 201 }
 202
 203 TemplateStatus
 204 Control::ApplyTemplateRoot (UIElement *root)
 205 {
 206         // If the template root is null, we treat the template as
 207         // not being applied
 208         if (!root)
 209                 return TemplateStatusNotApplied;
 210         if (root == template_root)
 211                 return TemplateStatusAlreadyApplied;
 212
 213         ElementAdded (root);
 214
 215         MoonError e;
 216         root->SetParent (this, &e);
 217         OnApplyTemplate ();
 218
 219         return TemplateStatusApplied;
 220 }
 221
 222 void
 223 Control::ClearTemplate ()
 224 {
 225         if (applied_template) {
 226                 applied_template->unref();
 227                 applied_template = NULL;
 228         }
 229
 230         ElementRemoved (template_root);
 231 }
 232
 233 void
 234 Control::OnApplyTemplate ()
 235 {
 236         Emit (TemplateAppliedEvent);
 237 }
 238
 239 void
 240 Control::ElementAdded (UIElement *item)
 241 {
 242         if (item == template_root)
 243                 return;
 244
 245         ElementRemoved (template_root);
 246
 247         template_root = item;
 248
 249         if (template_root) {
 250                 template_root->ref ();
 251                 FrameworkElement::ElementAdded (template_root);
 252         }
 253
 254         SetSubtreeObject (template_root);
 255 }
 256
 257 void
 258 Control::ElementRemoved (UIElement *item)
 259 {
 260         if (template_root && item == template_root) {
 261                 template_root->unref ();
 262                 template_root = NULL;
 263                 SetSubtreeObject (NULL);
 264         }
 265
 266         if (item)
 267                 FrameworkElement::ElementRemoved (item);
 268 }
 269
 270 DependencyObject *
 271 Control::GetTemplateChild (const char *name)
 272 {
 273         if (template_root)
 274                 return template_root->FindName (name);
 275
 276         return NULL;
 277 }
 278
 279 bool
 280 Control::Focus (bool recurse)
 281 {
 282         Surface *surface = GetSurface ();
 283         if (!surface)
 284                 return false;
 285
 286          /* according to msdn, these three things must be true for an element to be focusable:
 287          *
 288          * 1. the element must be visible
 289          * 2. the element must have IsTabStop = true
 290          * 3. the element must be part of the plugin's visual tree, and must have had its Loaded event fired.
 291          */
 292
 293          /*
 294          * If the current control is not focusable, we walk the visual tree and stop as soon
 295          * as we find the first focusable child. That then becomes focused
 296          */
 297         Types *types = Deployment::GetCurrent ()->GetTypes ();
 298         DeepTreeWalker walker (this);
 299         while (UIElement *e = walker.Step ()) {
 300                 if (!types->IsSubclassOf (e->GetObjectType (), Type::CONTROL))
 301                         continue;
 302
 303                 Control *c = (Control *)e;
 304                 if (!c->GetIsEnabled ()) {
 305                         if (!recurse)
 306                                 return false;
 307
 308                         walker.SkipBranch ();
 309                         continue;
 310                 }
 311
 312                 // A control is focusable if it is attached to a visual tree whose root
 313                 // element has been loaded
 314                 bool loaded = false;
 315                 for (UIElement *check = this; !loaded && check != NULL; check = check->GetVisualParent ())
 316                         loaded |= check->IsLoaded ();
 317
 318                 if (loaded && c->GetRenderVisible () && c->GetIsTabStop ())
 319                         return surface->FocusElement (c);
 320
 321                 if (!recurse)
 322                         return false;
 323         }
 324         return false;
 325 }
 326
 327 void
 328 Control::UpdateEnabled ()
 329 {
 330         Types *types = Deployment::GetCurrent ()->GetTypes ();
 331         DeepTreeWalker walker = DeepTreeWalker (this);
 332         while (UIElement *child = walker.Step ()) {
 333                 if (child == this || !types->IsSubclassOf (child->GetObjectType (), Type::CONTROL))
 334                         continue;
 335
 336                 Control *control = (Control *)child;
 337                 control->enabled_parent = (enabled_local && enabled_parent);
 338                 control->SetValue (Control::IsEnabledProperty, Value (control->enabled_local));
 339                 walker.SkipBranch ();
 340         }
 341 }