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