namespace UI
{
void DragDeltaEventArgs::InvokeEventHandler(Object* genericTarget, stub_interface_base* genericHandler)
{
stub_interface2<void, Object*, DragDeltaEventArgs*>* handler = dynamic_cast<stub_interface2<void, Object*, DragDeltaEventArgs*>*>(genericHandler);
ASSERT(handler);
handler->invoke(genericTarget, this);
}
/*
Thumb::Thumb()
{
Border* pBorder = new Border(new Thickness(1));
pBorder->set_BorderBrush(new LinearGradientBrush(new Color(255, 255, 255), new Color(0, 0, 0), new Point(0, 0), new Point(0, 1)));
// pBorder->set_BorderBrush(new SolidColorBrush(new Color(0, 0, 0)));
pBorder->set_Background(new SolidColorBrush(new Color(80, 114, 158)));
set_VisualTree(pBorder);
}
*/
DependencyProperty* Thumb::s_IsDraggingProperty = RegisterProperty(WSTR("IsDragging"), typeid(bool), typeid(Thumb), BoolObject::get_False(), PropertyMetaData(None));
RoutedEvent* Thumb::s_DragStartedEvent;
RoutedEvent* Thumb::s_DragCompletedEvent;
RoutedEvent* Thumb::s_DragDeltaEvent = EventManager::RegisterRoutedEvent(WSTR("DragDelta"), RoutingStrategy_Bubble, typeid(stub_interface2<void, Object*, DragDeltaEventArgs*>), typeid(Thumb));
//void ApplyStyle(Style* style, FrameworkElement* element);
//Object* CreateObjectFromElement(Type* pType, Object* parentObject, XmlData::Node* node, Type** pReturnType);
__live_object_ptr<Style> ThumbStyle;
Thumb::Thumb()
{
m_dragging = false;
if (ThumbStyle == NULL)
{
XmlData::Document* document = new XmlData::Document;
StringW* filename = MakeFilePath(_Module, L"../../../ThumbStyle.lxui");
document->load(filename);
Type* returnType;
ThumbStyle = dynamic_cast<Style*>(CreateObjectFromElement(NULL, NULL, document->get_documentElement(), &returnType));
}
set_Style(ThumbStyle);
/*
ApplyStyle(get_Style(), this);
InitScript();
*/
}
bool Thumb::get_IsDragging()
{
return static_cast<BoolObject*>(GetValue(get_IsDraggingProperty()))->GetValue();
}
void Thumb::set_IsDragging(bool dragging)
{
SetValue(get_IsDraggingProperty(), BoolObject::GetObject(dragging));
}
void Thumb::OnMouseDown(MouseButtonEventArgs* args)
{
if (!m_dragging)
{
CaptureMouse();
set_IsDragging(true);
m_dragging = true;
m_oldpoint = args->GetPosition(dynamic_cast<IInputElement*>(GetRParent()));//LDraw::PointD(mouseevt->get_ScreenX(), mouseevt->get_ScreenY());
}
args->set_Handled(true);
}
void Thumb::OnMouseUp(MouseButtonEventArgs* args)
{
if (m_dragging)
{
ReleaseMouseCapture();
set_IsDragging(false);
m_dragging = false;
}
args->set_Handled(true);
}
void Thumb::OnMouseMove(MouseEventArgs* args)
{
// Point point(mouseevt->get_ScreenX(), mouseevt->get_ScreenY());
Point point = args->GetPosition(dynamic_cast<IInputElement*>(GetRParent()));//point(mouseevt->get_ScreenX(), mouseevt->get_ScreenY());
if (m_dragging)
{
#if 0
DragDeltaEvent* dragevent = new DragDeltaEvent;
dragevent->InitEvent(WSTR("DragDelta"), true, true);
dragevent->m_HorizontalChange = point.X - m_oldpoint.X;
dragevent->m_VerticalChange = point.Y - m_oldpoint.Y;
m_oldpoint = point;
dispatchEvent(dragevent);
#endif
DragDeltaEventArgs* args = new DragDeltaEventArgs;
args->set_RoutedEvent(get_DragDeltaEvent());
args->m_HorizontalChange = point.X - m_oldpoint.X;
args->m_VerticalChange = point.Y - m_oldpoint.Y;
m_oldpoint = point;
RaiseEvent(args);
}
args->set_Handled(true);
}
#if 0
void Thumb::handleEvent(Event* evt)
{
StringW* type = evt->get_type();
if (evt->get_eventPhase() != CAPTURING_PHASE)
{
if (type == MouseEvent::mousedown)
{
MouseEvent* mouseevt = static_cast<MouseEvent*>(evt);
if (!m_dragging)
{
CaptureMouse();
m_dragging = true;
m_oldpoint = LDraw::PointD(mouseevt->get_ScreenX(), mouseevt->get_ScreenY());
}
// OnLButtonDown(static_cast<MouseEvent*>(evt));
evt->stopPropagation();
}
else if (type == MouseEvent::mouseup)
{
if (m_dragging)
{
ReleaseMouseCapture();
m_dragging = false;
}
// OnLButtonUp(static_cast<MouseEvent*>(evt));
evt->stopPropagation();
}
else if (type == MouseEvent::mousemove)
{
MouseEvent* mouseevt = static_cast<MouseEvent*>(evt);
//LDraw::PointD point = ScreenToClient(evt->get_ScreenX(), evt->get_ScreenY());
LDraw::PointD point(mouseevt->get_ScreenX(), mouseevt->get_ScreenY());
if (m_dragging)
{
DragDeltaEvent* dragevent = new DragDeltaEvent;
dragevent->InitEvent(WSTR("DragDelta"), true, true);
dragevent->m_HorizontalChange = point.X - m_oldpoint.X;
dragevent->m_VerticalChange = point.Y - m_oldpoint.Y;
m_oldpoint = point;
dispatchEvent(dragevent);
}
// OnMouseMove(static_cast<MouseEvent*>(evt));
evt->stopPropagation();
}
}
}
#endif
} // UI
namespace Media
{
DependencyProperty* TimelineGroup::s_ChildrenProperty = RegisterProperty(WSTR("Children"), typeid(TimelineCollection), typeid(TimelineGroup), NULL, PropertyMetaData(None));
TimelineCollection::TimelineCollection()
{
}
//
TimelineGroup::TimelineGroup()
{
set_Children(new TimelineCollection());
}
TimelineCollection* TimelineGroup::get_Children()
{
return static_cast<TimelineCollection*>(GetValue(get_ChildrenProperty()));
}
void TimelineGroup::set_Children(TimelineCollection* children)
{
SetValue(get_ChildrenProperty(), children);
}
} // Media
namespace Media
{
DependencyProperty* Timeline::s_DurationProperty = RegisterProperty(WSTR("Duration"), typeid(double), typeid(Timeline), DoubleObject::GetObject(1), PropertyMetaData(None));
DependencyProperty* Timeline::s_BeginTimeProperty = RegisterProperty(WSTR("BeginTime"), typeid(double), typeid(Timeline), DoubleObject::GetObject(0), PropertyMetaData(None));
DependencyProperty* Timeline::s_AutoReverseProperty = RegisterProperty(WSTR("AutoReverse"), typeid(bool), typeid(Timeline), BoolObject::GetObject(false), PropertyMetaData(None));
DependencyProperty* Timeline::s_FillBehaviorProperty = RegisterProperty(WSTR("FillBehavior"), typeid(FillBehavior), typeid(Timeline), IntObject::GetObject(FillBehavior_HoldEnd), PropertyMetaData(None));
DependencyProperty* Timeline::s_RepeatBehaviorProperty = RegisterProperty(WSTR("RepeatBehavior"), typeid(RepeatBehavior), typeid(Timeline), new RepeatBehavior(1.0), PropertyMetaData(None));
DependencyProperty* Timeline::s_SpeedRatioProperty = RegisterProperty(WSTR("SpeedRatio"), typeid(double), typeid(Timeline), DoubleObject::GetObject(1.0), PropertyMetaData(None));
DependencyProperty* Timeline::s_AccelerationRatioProperty = RegisterProperty(WSTR("Acceleration"), typeid(double), typeid(Timeline), DoubleObject::GetObject(0.0), PropertyMetaData(None));
DependencyProperty* Timeline::s_DecelerationRatioProperty = RegisterProperty(WSTR("Deceleration"), typeid(double), typeid(Timeline), DoubleObject::GetObject(0.0), PropertyMetaData(None));
Timeline::Timeline()
{
// m_containingElement = NULL;
}
#define REMAINDER(t, d) (t - d*floor(t/d))
double Timeline::ActiveTimeToSimpleTime(double tau, int* iteration)
{
// m_simpleDur has accounted for autoReverse
double m_AD = 99999;
double m_simpleDur = get_Duration();
double m_dur = get_Duration();
double AD = m_AD;//m_dur;// ? AD=Active Duration?
double speed = get_SpeedRatio();//m_speed->m_value->m_value->m_value;
double acc = get_AccelerationRatio();//m_accelerate->m_value->m_value->m_value;
double dec = get_DecelerationRatio();//m_decelerate->m_value->m_value->m_value;
if (acc+dec > 1) // Ignore both attributes
{
acc = 0;
dec = 0;
}
double taf;
if (speed > 0) // i.e. if the local speed is forwards
taf = tau * speed;
else // i.e. if the local speed is backwards
taf = AD - tau * fabs(speed);
//Let dur be the value of the simple duration as defined by the Timing and Synchronization model.
// This is the actual simple duration, and not simply the dur attribute.
//This value does not account for the effect of any time manipulations.
double dur = m_dur;
ASSERT(dur >= 0);
//if (dur < 0) dur = INDEFINITE; // indefinite (Is this correct?)
// m_simpleDur has accounted for autoReverse
double dur_ = m_simpleDur;
#if 1 // Have something like this
double tsu = REMAINDER(taf, dur_);
#else
double tsu = taf;
#endif
if (iteration)
{ // ??
*iteration = (int)(taf/dur_);
}
// Account for autoReverse behavior.
double tsu_;
if (!get_AutoReverse())
{
tsu_ = tsu;
}
else
{
if (tsu < dur)
tsu_ = tsu;
else
//tsu_ = /*dur - (tsu - dur) =*/ 2*dur - tsu;
tsu_ = 2*dur - tsu;
}
// Calculate filtered time (tsf)
// Account for acceleration/deceleration
double tsf;
double dacc = acc*dur;
double ddec = dec*dur;
double r = 1 / (1 - acc/2 - dec/2);
if (tsu_ >= 0 && tsu_ < dacc)
{
double rt = r * (tsu_ / dacc);
tsf = tsu_ * rt / 2;
}
else if (tsu_ > (dur - ddec))
{
double rt = r * (dur - tsu_) / ddec;
double tdec = tsu_ - (dur - ddec);
double pd = tdec / ddec;
tsf = r * (dur - dacc / 2 - ddec + tdec * (2 - pd) / 2);
}
else
{
tsf = r * (tsu_ - dacc / 2);
}
// tsf = tsf + m_iteration*dur_; // ???? TODO remove this
return tsf;
}
/*
Clock* Timeline::AllocateClock()
{
throw exception("");
ASSERT(0);
return NULL;
}
*/
double Timeline::GetNaturalDuration()
{
return 0;
}
/*
DependencyObject* Timeline::GetDependencyParent()
{
// ??
return NULL;
}
*/
/*
void Timeline::AddChild(System::Object* child)
{
m_animations.push_back(dynamic_cast<Animation*>(child));
}
void Timeline::AddText(System::StringW* text)
{
}
*/
Clock* Timeline::CreateClock(bool controllable)
{
Clock* clock = AllocateClock();
VERIFY(clock);
m_createdClocks.push_back(clock);
return clock;
}
//double fps = 20;
Nullable<double> Timeline::get_BeginTime()
{
// return static_cast<DoubleObject*>(GetValue(get_BeginTimeProperty()))->GetValue();
return unbox_nullable_cast<double>(GetValue(get_BeginTimeProperty()));
}
void Timeline::set_BeginTime(Nullable<double> duration)
{
SetValue(get_BeginTimeProperty(), box_nullable_cast(duration));
}
double Timeline::get_Duration()
{
return static_cast<DoubleObject*>(GetValue(get_DurationProperty()))->GetValue();
}
void Timeline::set_Duration(double duration)
{
SetValue(get_DurationProperty(), DoubleObject::GetObject(duration));
}
bool Timeline::get_AutoReverse()
{
return static_cast<BoolObject*>(GetValue(get_AutoReverseProperty()))->GetValue();
}
void Timeline::set_AutoReverse(bool autoReverse)
{
SetValue(get_AutoReverseProperty(), BoolObject::GetObject(autoReverse));
}
RepeatBehavior* Timeline::get_RepeatBehavior()
{
return static_cast<RepeatBehavior*>(GetValue(get_RepeatBehaviorProperty()));
}
void Timeline::set_RepeatBehavior(RepeatBehavior* repeatBehavior)
{
SetValue(get_RepeatBehaviorProperty(), repeatBehavior);
}
double Timeline::get_SpeedRatio()
{
return static_cast<DoubleObject*>(GetValue(get_SpeedRatioProperty()))->GetValue();
}
double Timeline::get_AccelerationRatio()
{
return static_cast<DoubleObject*>(GetValue(get_AccelerationRatioProperty()))->GetValue();
}
double Timeline::get_DecelerationRatio()
{
return static_cast<DoubleObject*>(GetValue(get_DecelerationRatioProperty()))->GetValue();
}
/*
void Timeline::Begin(Animatable* containingElement)
{
m_containingElement = containingElement;
m_time = 0;
m_timerID = SetTimer(1000.0 / fps, this);
}
*/
#if 0
void Timeline::dispatchEvent2(Event* evt, bool bCapture, bool* doDefault)
{
m_time += 1.0 / fps;
// MessageBeep(-1);
for (int i = 0; i < m_animations.size(); i++)
{
Animation* animation = m_animations[i];
if (m_time >= animation->get_Duration())
{
// MessageBeep(-1);
KillTimer(m_timerID);
return;
}
ASSERT(0);
DependencyProperty* property = NULL;//GetProperty(animation->m_targetProperty);
animation->m_currentTime = m_time;
//animation->Do(property, m_time);
m_containingElement->ApplyAnimation(property, animation);
}
}
#endif
} // Media
namespace UI
{
DependencyProperty* DockPanel::s_DockProperty = RegisterAttached(WSTR("Dock"), typeid(DockEnum), typeid(DockPanel), IntObject::GetObject(Left), PropertyMetaData(None));
DependencyProperty* DockPanel::s_LastChildFillProperty = RegisterProperty(WSTR("LastChildFill"), typeid(bool), typeid(DockPanel), BoolObject::get_True(), PropertyMetaData(None));
DockPanel::DockPanel()
{
}
bool DockPanel::get_LastChildFill()
{
return static_cast<BoolObject*>(GetValue(get_LastChildFillProperty()))->GetValue();
}
void DockPanel::set_LastChildFill(bool lastChildFill)
{
SetValue(get_LastChildFillProperty(), BoolObject::GetObject(lastChildFill));
}
// static
DockPanel::DockEnum DockPanel::GetDock(DependencyObject* pObject)
{
Object* obj = pObject->GetValue(get_DockProperty());
ASSERT(dynamic_cast<IntObject*>(obj));
System::IntObject* pInt = static_cast<IntObject*>(obj);
return (DockEnum)pInt->GetValue();
}
// static
void DockPanel::SetDock(DependencyObject* pObject, DockEnum newVal)
{
if (newVal != Left &&
newVal != Top &&
newVal != Right &&
newVal != Bottom &&
newVal != Fill)
{
ASSERT(0);
THROW(std::exception("Invalid Dock enum value"));
}
pObject->SetValue(get_DockProperty(), IntObject::GetObject(newVal));
}
// static
void DockPanel::ClearDock(DependencyObject* pObject)
{
pObject->ClearValue(get_DockProperty());
}
void DockPanel::RemoveChildren()
{
// ??
get_Children()->m_items.clear();
// ASSERT(0);
#if 0
for (int i = get_rchildList()->get_Size()-1; i >= 0; i--)
{
RemoveRChild((*get_rchildList())[i]);
}
#endif
InvalidateMeasure();
}
// virtual
LDraw::SizeD DockPanel::MeasureOverride(LDraw::SizeD availSize)
{
LDraw::BBoxD layoutRect(0, 0, availSize.Width, availSize.Height);
double minWidth = 0;
double minHeight = 0;
double totalWidth = 0;
double totalHeight = 0;
unsigned int ncount = get_InternalChildren()->GetCount();
#if 0
for (unsigned int i = 0; i < ncount; i++)
{
UIElement* pVisual = get_InternalChildren()->GetItem(i);//(*get_rchildList())[i];
// TODO remove this
// pVisual->SetRParent(this);
}
#endif
for (unsigned int i = 0; i < ncount; i++)
{
UIElement* pVisual = get_InternalChildren()->get_Item(i);//(*get_rchildList())[i];
ASSERT(pVisual->GetRParent() == this);
if (pVisual->get_Visibility() != Collapsed)
{
DockEnum dock = GetDock(pVisual);
if (dock == Fill || ((i == ncount-1) && get_LastChildFill()))
{
pVisual->Measure(LDraw::SizeD(layoutRect.GetWidth(), layoutRect.GetHeight()));
totalWidth += pVisual->get_DesiredSize().Width;
totalHeight += pVisual->get_DesiredSize().Height;
break;
}
else if (dock == Left)
{
pVisual->Measure(LDraw::SizeD(0, layoutRect.GetHeight()));
layoutRect.left += pVisual->get_DesiredSize().Width;
totalWidth += pVisual->get_DesiredSize().Width;
// totalHeight = max(totalHeight, pVisual->m_desiredHeight);
minHeight = MAX(minHeight, pVisual->get_DesiredSize().Height);
}
else if (dock == Top)
{
pVisual->Measure(LDraw::SizeD(layoutRect.GetWidth(), 0));
layoutRect.top += pVisual->get_DesiredSize().Height;
totalHeight += pVisual->get_DesiredSize().Height;
// totalWidth = max(totalWidth, pVisual->m_desiredWidth);
minWidth = MAX(minWidth, pVisual->get_DesiredSize().Width);
}
else if (dock == Right)
{
pVisual->Measure(LDraw::SizeD(0, layoutRect.GetHeight()));
layoutRect.right -= pVisual->get_DesiredSize().Width;
totalWidth += pVisual->get_DesiredSize().Width;
// totalHeight = max(totalHeight, pVisual->m_desiredHeight);
minHeight = MAX(minHeight, pVisual->get_DesiredSize().Height);
}
else if (dock == Bottom)
{
pVisual->Measure(LDraw::SizeD(layoutRect.GetWidth(), 0));
layoutRect.bottom -= pVisual->get_DesiredSize().Height;
totalHeight += pVisual->get_DesiredSize().Height;
// totalWidth = max(totalWidth, pVisual->m_desiredWidth);
minWidth = MAX(minWidth, pVisual->get_DesiredSize().Width);
}
else
ASSERT(0);
// pVisual->SetLayoutOffset(fLeft, fTop);
// pVisual->Arrange(LDraw::SizeF(pVisual->m_computedWidth, pVisual->m_computedHeight));
/*
if (dock == Fill ||
layoutRect.GetWidth() <= 0 ||
layoutRect.GetHeight() <= 0)
{
break;
}
*/
}
}
return LDraw::SizeD(MAX(minWidth, totalWidth), MAX(minHeight, totalHeight));
}
// virtual
LDraw::SizeD DockPanel::ArrangeOverride(LDraw::SizeD finalSize)
{
LDraw::BBoxD layoutRect(0, 0, finalSize.Width, finalSize.Height);
unsigned int ncount = get_InternalChildren()->GetCount();//get_rchildList()->get_Size();
for (unsigned int i = 0; i < ncount; i++)
{
UIElement* pVisual = get_InternalChildren()->get_Item(i);//(*get_rchildList())[i];
if (pVisual->get_Visibility() != Collapsed)
{
// long dockValue;
DockEnum dock = GetDock(pVisual);
ASSERT(pVisual->get_DesiredSize().Width >= 0 && pVisual->get_DesiredSize().Height >= 0);
// double fLeft;
// double fTop;
if (dock == Fill || ((i == ncount-1) && get_LastChildFill()))
{
pVisual->Arrange(layoutRect);//LDraw::RectD(layoutRect.GetWidth(), layoutRect.GetHeight()));
// fLeft = layoutRect.left;
// fTop = layoutRect.top;
}
else if (dock == Left)
{
pVisual->Arrange(LDraw::RectD(layoutRect.left, layoutRect.top, pVisual->get_DesiredSize().Width, layoutRect.GetHeight()));
// fLeft = layoutRect.left;
// fTop = layoutRect.top;
layoutRect.left += pVisual->get_ActualSize().Width;
}
else if (dock == Top)
{
pVisual->Arrange(LDraw::RectD(layoutRect.left, layoutRect.top, layoutRect.GetWidth(), pVisual->get_DesiredSize().Height));
// fLeft = layoutRect.left;
// fTop = layoutRect.top;
layoutRect.top += pVisual->get_ActualSize().Height;
}
else if (dock == Right)
{
pVisual->Arrange(LDraw::RectD(layoutRect.right - pVisual->get_DesiredSize().Width, layoutRect.top, pVisual->get_DesiredSize().Width, layoutRect.GetHeight()));
// fLeft = layoutRect.right - pVisual->get_ActualSize().Width;
// fTop = layoutRect.top;
layoutRect.right -= pVisual->get_ActualSize().Width;
}
else if (dock == Bottom)
{
pVisual->Arrange(LDraw::RectD(layoutRect.left, layoutRect.bottom - pVisual->get_DesiredSize().Height, layoutRect.GetWidth(), pVisual->get_DesiredSize().Height));
// fLeft = layoutRect.left;
// fTop = layoutRect.bottom - pVisual->get_ActualSize().Height;
layoutRect.bottom -= pVisual->get_ActualSize().Height;
}
else
ASSERT(0);
// pVisual->SetLayoutOffset(fLeft, fTop);
if (dock == Fill ||
layoutRect.GetWidth() <= 0 ||
layoutRect.GetHeight() <= 0)
{
break;
}
}
}
return finalSize;
}
} // UI
namespace Shapes
{
DependencyProperty* Rectangle::s_RadiusXProperty = RegisterProperty(WSTR("RadiusX"), typeid(double), typeid(Rectangle), DoubleObject::GetObject(0), PropertyMetaData(AffectsRender));
DependencyProperty* Rectangle::s_RadiusYProperty = RegisterProperty(WSTR("RadiusY"), typeid(double), typeid(Rectangle), DoubleObject::GetObject(0), PropertyMetaData(AffectsRender));
Rectangle::Rectangle()
{
// m_RadiusX = NULL;
// m_RadiusY = NULL;
SetClipMode(false);
/*
m_RectangleLeft = NULL;
m_RectangleTop = NULL;
m_RectangleWidth = NULL;
m_RectangleHeight = NULL;
m_RadiusX = NULL;
m_RadiusY = NULL;
*/
}
Rectangle::~Rectangle()
{
}
DependencyProperty* Rectangle::get_RadiusXProperty()
{
return s_RadiusXProperty;
}
DependencyProperty* Rectangle::get_RadiusYProperty()
{
return s_RadiusYProperty;
}
#if 0
LDraw::SizeD Rectangle::MeasureOverride(LDraw::SizeD availSize)
{
if (m_RadiusX != NULL)
{
double Value = m_RadiusX->get_Value();
if (m_RadiusX->get_UnitType() == LengthUnits::Percentage)
{
m_computedRadiusX = Value * availSize.Width;
}
else
{
m_computedRadiusX = Value;
}
}
else
{
m_computedRadiusX = 0;
}
if (m_RadiusY != NULL)
{
double Value = m_RadiusY->get_Value();
if (m_RadiusY->get_UnitType() == LengthUnits::Percentage)
{
m_computedRadiusY = Value * availSize.Height;
}
else
{
m_computedRadiusY = Value;
}
}
else
{
m_computedRadiusY = 0;
}
return Shape::MeasureOverride(availSize);
/*
if (!m_RectangleLeft.IsNull())
{
double Value = m_RectangleLeft.get_Value();
if (m_RectangleLeft.get_UnitType() == Length::UnitPercentage)
{
m_computedRectangleLeft = Value * availSize.Width;
}
else
{
m_computedRectangleLeft = Value;
}
}
else
{
m_computedRectangleLeft = 0;
}
if (!m_RectangleTop.IsNull())
{
double Value = m_RectangleTop.get_Value();
if (m_RectangleTop.get_UnitType() == Length::UnitPercentage)
{
m_computedRectangleTop = Value * availSize.Height;
}
else
{
m_computedRectangleTop = Value;
}
}
else
{
m_computedRectangleTop = 0;
}
if (!m_RectangleWidth.IsNull())
{
double Value = m_RectangleWidth.get_Value();
if (m_RectangleWidth.get_UnitType() == Length::UnitPercentage)
{
m_computedRectangleWidth = Value * availSize.Width;
}
else
{
m_computedRectangleWidth = Value;
}
}
else
{
m_computedRectangleWidth = 0;
}
if (!m_RectangleHeight.IsNull())
{
double Value = m_RectangleHeight.get_Value();
if (m_RectangleHeight.get_UnitType() == Length::UnitPercentage)
{
m_computedRectangleHeight = Value * availSize.Height;
}
else
{
m_computedRectangleHeight = Value;
}
}
else
{
m_computedRectangleHeight = 0;
}
*/
/*
m_RenderBounds.X = m_computedRectangleLeft;
m_RenderBounds.Y = m_computedRectangleTop;
m_RenderBounds.Width = m_computedRectangleWidth;
m_RenderBounds.Height = m_computedRectangleHeight;
m_expandedBBox = m_RenderBounds;
return LDraw::SizeD(m_computedRectangleWidth, m_computedRectangleHeight);
*/
}
#endif
LDraw::SizeD Rectangle::ArrangeOverride(LDraw::SizeD finalSize)
{
m_computedRadiusX = get_RadiusX();
m_computedRadiusY = get_RadiusY();
return finalSize;
// Shape::OnArrange(finalSize);
//m_expandedBBox = m_RenderBounds;
}
// virtual
bool Rectangle::HitTest(double x, double y/*, long pointerEvents*/)
{
// TODO
return true;
}
// virtual
__release<LDraw::Region> Rectangle::OnGetOpaqueRegion(LDraw::Matrix3f* transform)
{
LDraw::PointD xpt = transform->Transform(LDraw::PointD(m_expandedBBox.X, m_expandedBBox.Y));
m_bDrawsOutsideOpaqueRegion = false;
return new LDraw::Region(LDraw::RectI(xpt.X, xpt.Y, m_expandedBBox.Width, m_expandedBBox.Height));
}
#if 0
// virtual
void Rectangle::Clip(Graphics* pGraphics, LDraw::Region * rgn)
{
//LDraw::Matrix3f oldTransform = pGraphics->GetTransform();
pGraphics->PushTransform();//m_transformMatrix);
{
LDraw::PointD xpt = pGraphics->GetTransform()->Transform(LDraw::PointD(m_expandedBBox.X, m_expandedBBox.Y));
ASSERT(0);
#if 0
rgn->Exclude(LDraw::RectI(xpt.X, xpt.Y, m_expandedBBox.Width, m_expandedBBox.Height));
#endif
/*
HRGN rect = CreateRectRgn(xpt[0], xpt[1], xpt[0]+m_expandedBBox.Width, xpt[1]+m_expandedBBox.Height);
CombineRgn(rgn.m_hRgn, rgn.m_hRgn, rect, RGN_DIFF);
DeleteObject(rect);
*/
}
pGraphics->PopTransform();//oldTransform);
/*
// The default is not to clip
if (m_computedRectangleWidth > 0 && m_computedRectangleHeight > 0)
{
HRGN rect = CreateRectRgn(m_computedRectangleLeft, m_computedRectangleTop, m_computedRectangleWidth, m_computedRectangleHeight);
CombineRgn(hRgn, hRgn, rect, RGN_DIFF);
DeleteObject(rect);
}
*/
}
#endif
// virtual
void Rectangle::OnRender(Graphics* pGraphics)
{
LDraw::SizeD actualSize = get_ActualSize();
//if (m_computedRectangleWidth > 0 && m_computedRectangleHeight > 0)
{
// LDraw::SmoothingMode oldSmoothingMode = pGraphics->GetSmoothingMode();
// pGraphics->SetSmoothingMode(LDraw::SmoothingModeHighQuality);
// __release<LDraw::GraphicsPathF> path = new LDraw::GraphicsPathF;
//#if _WINDOWS
// RoundRect(&path, m_computedRectangleLeft, m_computedRectangleTop, m_computedRectangleWidth, m_computedRectangleHeight, m_computedRadiusX, m_computedRadiusY);
//#else
// path->AddRoundRect(0, 0, actualSize.Width, actualSize.Height, m_computedRadiusX, m_computedRadiusY);
//#endif
// pGraphics->FillPath(&LDraw::SolidBrush(LDraw::Color(255, 0, 0)), &path);
Brush* Fill = get_Fill();
if (Fill)
{
__release<LDraw::Brush> brush = Fill->CreateBrush(this, 1, 1);
if (brush != NULL)
{
pGraphics->FillRectangle(brush, 0, 0, actualSize.Width, actualSize.Height);
#if 0
pGraphics->FillRectangle(pBrush, m_computedRectangleLeft, m_computedRectangleTop, m_computedRectangleWidth, m_computedRectangleHeight);
pGraphics->Clear(LDraw::Color(255, 0, 0));
pGraphics->FillPath(brush, path);
#endif
}
}
#if 0//_WINDOWS
double StrokeThickness;
if (m_StrokeThickness)
StrokeThickness = m_StrokeThickness->get_Value();
else
StrokeThickness = 1;
if (StrokeThickness > 0)
{
CLXUIElementImpl* Stroke = m_Stroke;
if (Stroke)
{
LDraw::Brush* pBrush = Stroke->CreateBrush(this, 1, 1);
if (pBrush)
{
LDraw::Pen pen(pBrush, StrokeThickness);
pGraphics->DrawPath(pen, &path);
delete pBrush;
}
}
}
#endif
// pGraphics->SetSmoothingMode(oldSmoothingMode);
//#elif AMIGA
// pGraphics->FillRectangle(&LDraw::SolidBrush(LDraw::Color(255, 0, 0)), m_computedRectangleLeft, m_computedRectangleTop, m_computedRectangleWidth, m_computedRectangleHeight);
//#endif
}
}
/*
Length Rectangle::get_RectangleLeft()
{
return m_RectangleLeft;
}
void Rectangle::put_RectangleLeft(Length newVal)
{
m_RectangleLeft = newVal;
}
Length Rectangle::get_RectangleTop()
{
return m_RectangleTop;
}
void Rectangle::put_RectangleTop(Length newVal)
{
m_RectangleTop = newVal;
}
Length Rectangle::get_RectangleWidth()
{
return m_RectangleWidth;
}
void Rectangle::put_RectangleWidth(Length newVal)
{
m_RectangleWidth = newVal;
}
Length Rectangle::get_RectangleHeight()
{
return m_RectangleHeight;
}
void Rectangle::put_RectangleHeight(Length newVal)
{
m_RectangleHeight = newVal;
}
*/
double Rectangle::get_RadiusX()
{
return static_cast<DoubleObject*>(GetValue(get_RadiusXProperty()))->GetValue();
}
void Rectangle::set_RadiusX(double newVal)
{
SetValue(get_RadiusXProperty(), DoubleObject::GetObject(newVal));
}
double Rectangle::get_RadiusY()
{
return static_cast<DoubleObject*>(GetValue(get_RadiusYProperty()))->GetValue();
}
void Rectangle::set_RadiusY(double newVal)
{
SetValue(get_RadiusYProperty(), DoubleObject::GetObject(newVal));
}
} // Shapes
namespace UI
{
/*
class CreateIfNull
{
public:
CreateIfNull();
};
CreateIfNull createifnull;
CreateIfNull::CreateIfNull()
{
if (SolidColorBrush::ColorProperty == NULL)
{
SolidColorBrush::ColorProperty = RegisterProperty(WSTR("Color"), typeid(Color), typeid(SolidColorBrush), NULL, PropertyMetaData(None));
}
}
*/
DependencyProperty* SolidColorBrush::s_ColorProperty = RegisterProperty(WSTR("Color"), typeid(Color), typeid(SolidColorBrush), new Color(), PropertyMetaData(None));
SolidColorBrush::SolidColorBrush()
{
/*
if (ColorProperty == NULL)
{
ColorProperty = RegisterProperty(WSTR("Color"), typeid(Color), typeid(SolidColorBrush), NULL, PropertyMetaData(None));
}
*/
// m_Color = NULL;
// m_Opacity = 1.0;
}
SolidColorBrush::SolidColorBrush(Color color)
{
/*
if (ColorProperty == NULL)
{
ColorProperty = RegisterProperty(WSTR("Color"), typeid(Color), typeid(SolidColorBrush), NULL, PropertyMetaData(None));
}
*/
set_Color(color);
}
SolidColorBrush::SolidColorBrush(Color color, double opacity)
{
/*
if (ColorProperty == NULL)
{
ColorProperty = RegisterProperty(WSTR("Color"), typeid(Color), typeid(SolidColorBrush), NULL, PropertyMetaData(None));
}
*/
set_Color(color);
set_Opacity(opacity);
}
// virtual
__release<LDraw::Brush> SolidColorBrush::CreateBrush(UIElement* pReferencingElement, double scaleX, double scaleY)
{
int opacity = get_Opacity()*255;
if (opacity < 0) opacity = 0;
else if (opacity > 255) opacity = 255;
Color color = get_Color();
// if (color != NULL)
{
LDraw::Color dcolor = LDraw::Color(color.get_A()*opacity/255, color.get_R(), color.get_G(), color.get_B());
return new LDraw::SolidBrush(dcolor);
}
/* else
{
return NULL;
}
*/
}
Color SolidColorBrush::get_Color()
{
return *static_cast<Color*>(GetValue(get_ColorProperty()));
}
void SolidColorBrush::set_Color(Color newVal)
{
SetValue(get_ColorProperty(), new Color(newVal));
}
} // UI
namespace UI
{
DependencyProperty* RangeBase::s_MinimumProperty = RegisterProperty(WSTR("Minimum"), typeid(double), typeid(RangeBase), DoubleObject::GetObject(0.0), PropertyMetaData(None));
DependencyProperty* RangeBase::s_MaximumProperty = RegisterProperty(WSTR("Maximum"), typeid(double), typeid(RangeBase), DoubleObject::GetObject(1.0), PropertyMetaData(None));
DependencyProperty* RangeBase::s_ValueProperty = RegisterProperty(WSTR("Value"), typeid(double), typeid(RangeBase), DoubleObject::GetObject(0.0), PropertyMetaData(None));
RoutedEvent* RangeBase::s_ValueChangedEvent = EventManager::RegisterRoutedEvent(WSTR("ValueChanged"), RoutingStrategy_Bubble, typeid(stub_interface2<void, Object*, RoutedPropertyChangedEventArgs<double>*>), typeid(RangeBase));
template class UIEXT RoutedPropertyChangedEventArgs<double>;
template class UIEXT signal2<Object*, RoutedPropertyChangedEventArgs<double>*>;
RangeBase::RangeBase()
{
}
double RangeBase::get_Value()
{
return static_cast<DoubleObject*>(GetValue(get_ValueProperty()))->GetValue();
}
void RangeBase::set_Value(double value)
{
SetValue(get_ValueProperty(), DoubleObject::GetObject(value));
}
double RangeBase::get_Minimum()
{
return static_cast<DoubleObject*>(GetValue(get_MinimumProperty()))->GetValue();
}
void RangeBase::set_Minimum(double minimum)
{
SetValue(get_MinimumProperty(), DoubleObject::GetObject(minimum));
}
double RangeBase::get_Maximum()
{
return static_cast<DoubleObject*>(GetValue(get_MaximumProperty()))->GetValue();
}
void RangeBase::set_Maximum(double maximum)
{
SetValue(get_MaximumProperty(), DoubleObject::GetObject(maximum));
}
signal2<Object*, RoutedPropertyChangedEventArgs<double>*>& RangeBase::get_ValueChanged()
{
RoutedEvent* routedEvent = get_ValueChangedEvent();
int index = routedEvent->GetIndex();
if (m_handlers[index] == NULL)
{
VERIFY(routedEvent->get_HandlerType()->GetClass());
ClassType* pSigType = dynamic_cast<ClassType*>(routedEvent->get_HandlerType()->GetClass()->LookupType(ASTR("signal_type"))->GetStripped());
VERIFY(pSigType);
m_handlers[index] = (signal_base*)newobj(pSigType);
}
return *dynamic_cast<signal2<Object*, RoutedPropertyChangedEventArgs<double>*>*>(m_handlers[index]);
}
} // UI
namespace UI
{
namespace Data
{
CollectionView::CollectionView()
{
}
CollectionView::CollectionView(IObjectCollection* sourceCollection)
{
m_sourceCollection = sourceCollection;
}
unsigned int CollectionView::GetCount()
{
return m_items.size();
}
Object* CollectionView::GetItemAt(unsigned int index)
{
return m_items[index];
}
bool CollectionView::Contains(Object* object)
{
ASSERT(0);
return false;
}
int CollectionView::IndexOf(Object* item)
{
ASSERT(0);
return -1;
}
bool CollectionView::PassesFilter(Object* object)
{
// TODO
return true;
}
IObjectCollection* CollectionView::get_SourceCollection()
{
return m_sourceCollection;
}
} // Data
ItemCollection::ItemCollection()
{
m_sourceCollection = new Vector<Object*>;
}
void ItemCollection::Add(Object* item)
{
m_sourceCollection->AddObject(item);
// TODO, improve
m_owner->SetValue(m_owner->get_HasItemsProperty(), BoolObject::get_True());
m_owner->AddItem(item);
}
DependencyObject* ItemContainerGenerator::ContainerFromIndex(unsigned int index)
{
return m_panel->get_Children()->get_Item(index);
// return m_containers[index];
}
DependencyObject* ItemContainerGenerator::ContainerFromItem(Object* object)
{
ASSERT(0);
return NULL;
}
Object* ItemContainerGenerator::ItemFromContainer(DependencyObject* object)
{
return dynamic_cast<ContentControl*>(object)->get_Content();
}
DependencyProperty* ItemsControl::s_ItemsPanelProperty = RegisterProperty(WSTR("ItemsPanel"), typeid(ItemsPanelTemplate), typeid(ItemsControl), NULL, PropertyMetaData(None));
DependencyProperty* ItemsControl::s_HasItemsProperty = RegisterProperty(WSTR("HasItems"), typeid(bool), typeid(ItemsControl), BoolObject::get_False(), PropertyMetaData(None));
ItemsControl::ItemsControl()
{
m_items = new ItemCollection;
m_items->m_owner = this;
}
bool ItemsControl::get_HasItems()
{
return static_cast<BoolObject*>(GetValue(get_HasItemsProperty()))->GetValue();
}
void ItemsControl::OnApplyTemplate()
{
Control::OnApplyTemplate();
m_itemsPresenter = dynamic_cast<ItemsPresenter*>(get_VisualTree()->FindByType((ClassType*)typeid(ItemsPresenter).GetType()));
// if (m_itemsPresenter == NULL)
// m_itemsPresenter = dynamic_cast<ItemsPresenter*>(get_VisualTree()->FindByType((ClassType*)typeid(ItemsPresenter).GetType()));
if (m_itemsPresenter)
{
ItemsPanelTemplate* itemsPanelTemplate = get_ItemsPanel();
ASSERT(m_objectpropertymap.size() == 0);
Type* pRealType;
Object* obj = itemsPanelTemplate->get_VisualTree()->Create4(NULL, &pRealType, this/*???*/, m_objectpropertymap);
m_itemsPresenter->m_panel = dynamic_cast<Panel*>(obj);
m_itemContainerGenerator = new ItemContainerGenerator; // hm..
m_itemContainerGenerator->m_panel = m_itemsPresenter->m_panel;
m_itemsPresenter->set_VisualTree(m_itemsPresenter->m_panel);
}
}
ItemCollection* ItemsControl::get_Items()
{
return m_items;
}
ItemsPanelTemplate* ItemsControl::get_ItemsPanel()
{
return static_cast<ItemsPanelTemplate*>(GetValue(get_ItemsPanelProperty()));
}
void ItemsControl::set_ItemsPanel(ItemsPanelTemplate* itemsPanel)
{
SetValue(get_ItemsPanelProperty(), itemsPanel);
}
// Default implementation, override if this isn't what you want
void ItemsControl::AddItem(Object* item)
{
ContentControl* contentItem = dynamic_cast<ContentControl*>(item);
if (contentItem == NULL)
{
contentItem = new ContentControl;
contentItem->set_Content(item);
}
// m_owner->m_itemContainerGenerator->m_containers.push_back(listboxitem);
if (m_itemsPresenter)
{
m_itemsPresenter->m_panel->AddChild(contentItem);
}
}
} // UI
namespace Shapes
{
DependencyProperty* Polyline::s_PointsProperty = RegisterProperty(WSTR("Points"), typeid(PointCollection), typeid(Polyline), NULL, PropertyMetaData(AffectsMeasure));
Polyline::Polyline()
{
// SetClipMode(false);
}
Polyline::~Polyline()
{
}
LDraw::SizeD Polyline::MeasureOverride(LDraw::SizeD availSize)
{
PointCollection* points = get_Points();
if (points)
{
int count = points->GetCount();
if (count > 0)
{
__release<LDraw::GraphicsPathF> path = new LDraw::GraphicsPathF;
//CLXUIPoint* pOldPoint = static_cast<CLXUIPoint*>(points->m_items[0]);
Point point = points->get_Item(0);
path->AddMove(point.X, point.Y);
for (int i = 1; i < count; i++)
{
point = points->get_Item(i);
path->AddLine(point.X, point.Y);
// CLXUIPoint* pPoint = static_cast<CLXUIPoint*>(points->m_items[i]);
// path.AddLine(float(pOldPoint->m_X), float(pOldPoint->m_Y), float(pPoint->m_X), float(pPoint->m_Y));
// pOldPoint = pPoint;
}
LDraw::RectF rect;
path->GetBounds(&rect, NULL, NULL);
return LDraw::SizeD(rect.Width, rect.Height);
}
}
return LDraw::SizeD(0, 0);
}
// virtual
void Polyline::OnRender(Graphics* pGraphics)
{
PointCollection* points = get_Points();
if (points)
{
unsigned int count = points->GetCount();
if (count > 0)
{
__release<LDraw::GraphicsPathF> path = new LDraw::GraphicsPathF;
Point point = points->get_Item(0);
path->AddMove(point.X, point.Y);
for (unsigned int i = 1; i < count; i++)
{
point = points->get_Item(i);
path->AddLine(point.X, point.Y);
}
Brush* Fill = get_Fill();
if (Fill)
{
__release<LDraw::Brush> brush = Fill->CreateBrush(this, 1, 1);
if (brush != NULL)
{
pGraphics->FillPath(brush, path);
}
}
#if 0
double StrokeThickness;
if (m_StrokeThickness)
m_StrokeThickness->get_Value(&StrokeThickness);
else
StrokeThickness = 1;
if (StrokeThickness > 0)
{
CComQIPtr<CLXUIElementImplImpl> Stroke(m_Stroke);
if (Stroke)
{
Gdiplus::Brush* pBrush = Stroke->CreateBrush(this, 1, 1);
if (pBrush)
{
Gdiplus::Pen pen(pBrush, StrokeThickness);
pGraphics->DrawPath(pen, &path);
delete pBrush;
}
}
}
#endif
}
}
}
PointCollection* Polyline::get_Points()
{
return static_cast<PointCollection*>(GetValue(get_PointsProperty()));
}
void Polyline::set_Points(PointCollection* newVal)
{
SetValue(get_PointsProperty(), newVal);
}
} // Shapes
