public Comment(Node hostNode)
        {
            HostNode = hostNode;

            var scrollViewer = new ScrollViewer
            {
                HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled,
                VerticalScrollBarVisibility = ScrollBarVisibility.Visible,
                Height = 70,
                CanContentScroll = true
            };

            var textBlock = new TextBlock
            {
                Background = Brushes.Transparent,
                TextWrapping = TextWrapping.Wrap,
                Margin = new Thickness(5),
                FontSize = 12
            };

            Child = scrollViewer;
            CornerRadius = new CornerRadius(5);
            scrollViewer.Content = textBlock;


            var bindingTextToTextBlock = new Binding("Text")
            {
                Source = this,
                Mode = BindingMode.OneWay
            };
            textBlock.SetBinding(TextBlock.TextProperty, bindingTextToTextBlock);

            hostNode.SpaceCanvas.Children.Add(this);
        }

 public HorizontalMouseScrollHelper(ScrollViewer scrollviewer, DependencyObject d)
 {
     scrollViewer = scrollviewer;
     source = (HwndSource)PresentationSource.FromDependencyObject(d);
     if (source != null)
         source.AddHook(WindowProc);
 }

        public ExamineKeystrokes()
        {
            Title = "Examine Keystrokes";
            FontFamily = new FontFamily("Courier New");

            Grid grid = new Grid();
            Content = grid;

            // Make one row "auto" and the other fill the remaining space.
            RowDefinition rowdef = new RowDefinition();
            rowdef.Height = GridLength.Auto;
            grid.RowDefinitions.Add(rowdef);
            grid.RowDefinitions.Add(new RowDefinition());

            // Display header text.
            TextBlock textHeader = new TextBlock();
            textHeader.FontWeight = FontWeights.Bold;
            textHeader.Text = strHeader;
            grid.Children.Add(textHeader);

            // Create StackPanel as child of ScrollViewer for displaying events.
            scroll = new ScrollViewer();
            grid.Children.Add(scroll);
            Grid.SetRow(scroll, 1);

            stack = new StackPanel();
            scroll.Content = stack;
        }

        public PageCalendar()
        {
            InitializeComponent();

            this.Uid = "1000";
            this.Title = Translator.GetInstance().GetString("PageCalendar", this.Uid);

            StackPanel calendarPanel = new StackPanel();
            calendarPanel.Margin = new Thickness(10, 0, 10, 0);

            cbShowAll = new CheckBox();
            cbShowAll.Content = Translator.GetInstance().GetString("PageCalendar","200");
            cbShowAll.FlowDirection = System.Windows.FlowDirection.RightToLeft;
            cbShowAll.Checked += new RoutedEventHandler(cbShowAll_Checked);
            cbShowAll.Unchecked += new RoutedEventHandler(cbShowAll_Unchecked);
            cbShowAll.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
            cbShowAll.IsChecked = false;

            calendarPanel.Children.Add(cbShowAll);

            ScrollViewer viewer = new ScrollViewer();
            viewer.MaxHeight = GraphicsHelpers.GetContentHeight() - 50;

            ucCalendar = new ucCalendar();

            viewer.Content = ucCalendar;

            calendarPanel.Children.Add(viewer);

            base.setContent(calendarPanel);

            base.setHeaderContent(this.Title);

            showPage(this);
        }

        private void DocumentViewLoaded(object sender, RoutedEventArgs e)
        {
            using (var stream = Assembly.GetEntryAssembly().GetManifestResourceStream("MarkPad.Syntax.Markdown.xshd"))
            using (var reader = new XmlTextReader(stream))
            {
                Editor.SyntaxHighlighting = HighlightingLoader.Load(reader, HighlightingManager.Instance);
            }

            documentScrollViewer = Editor.FindVisualChild<ScrollViewer>();

            if (documentScrollViewer != null)
            {
                documentScrollViewer.ScrollChanged += (i, j) => wb.ExecuteJavascript("window.scrollTo(0," + j.VerticalOffset + ");");
                var x = ((DocumentViewModel)DataContext);
                x.Document.TextChanged += (i, j) =>
                                              {
                                                  wb.LoadCompleted += (k, l) => wb.ExecuteJavascript("window.scrollTo(0," + documentScrollViewer.VerticalOffset + ");");
                                              };
            }

            //  AvalonEdit hijacks Ctrl+I. We need to free that mutha up
            var editCommandBindings = Editor.TextArea.DefaultInputHandler.Editing.CommandBindings;

            editCommandBindings
                .FirstOrDefault(b => b.Command == ICSharpCode.AvalonEdit.AvalonEditCommands.IndentSelection)
                .ExecuteSafely(b => editCommandBindings.Remove(b));
        }

 public ScrollAdjustmentBackend(ScrollViewer s, bool isVertical)
 {
     TargetScrollViewer = s;
     this.isVertical = isVertical;
     scrollValue = 0;
     lowerValue = 0;
 }

        public WatchNode(Core.VplControl hostCanvas) : base(hostCanvas)
        {
            AddInputPortToNode("Object", typeof (object));

            var textBlock = new TextBlock
            {
                TextWrapping = TextWrapping.Wrap,
                FontSize = 14,
                Padding = new Thickness(5),
                IsHitTestVisible = false
            };

            var scrollViewer = new ScrollViewer
            {
                HorizontalScrollBarVisibility = ScrollBarVisibility.Auto,
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
                MinWidth = 120,
                MinHeight = 20,
                MaxWidth = 200,
                MaxHeight = 400,
                CanContentScroll = true,
                Content = textBlock
                //IsHitTestVisible = false
            };


            AddControlToNode(scrollViewer);
        }

 public ScrollControlBackend(ScrollViewer s, bool isVertical)
 {
     targetScrollViewer = s;
     this.isVertical = isVertical;
     scrollValue = Value;
     targetScrollViewer.ScrollChanged += HandleScrollChanged;
 }

        // --------------------------------------------------------------------
        // Ctor and event handlers
        // --------------------------------------------------------------------
        public SyntaxHighlightBox()
        {
            InitializeComponent();

            MaxLineCountInBlock = 100;
            LineHeight = FontSize * 1.3;
            totalLineCount = 1;
            blocks = new List<InnerTextBlock>();

            Loaded += (s, e) => {
                renderCanvas = (DrawingControl)Template.FindName("PART_RenderCanvas", this);
                scrollViewer = (ScrollViewer)Template.FindName("PART_ContentHost", this);

                scrollViewer.ScrollChanged += OnScrollChanged;

                InvalidateBlocks(0);
                InvalidateVisual();
            };

            SizeChanged += (s, e) => {
                if (e.HeightChanged == false)
                    return;
                UpdateBlocks();
                InvalidateVisual();
            };

            TextChanged += (s, e) => {
                UpdateTotalLineCount();
                InvalidateBlocks(e.Changes.First().Offset);
                InvalidateVisual();
            };
        }

 public override void OnApplyTemplate()
 {
     base.OnApplyTemplate();
     ParamContainer = GetTemplateChild(PART_ParamContainer) as Grid;
     paramsScroller = GetTemplateChild(PART_ParamsScroller) as ScrollViewer;
     BuildUI();
 }

        private void WpfPropertyPage_Load(object sender, EventArgs e) {
            SuspendLayout();

            _host = new PropertyPageElementHost();
            _host.AutoSize = false;
            _host.Dock = DockStyle.Fill;

            if (_control == null) {
                _control = CreatePropertyPageControl();
            }

            ScrollViewer viewer = new ScrollViewer {
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
                HorizontalScrollBarVisibility = ScrollBarVisibility.Auto
            };

            viewer.Content = _control;
            _host.Child = viewer;

            wpfHostPanel.Dock = DockStyle.Fill;
            wpfHostPanel.Controls.Add(_host);

            ResumeLayout(true);
            _control.StatusChanged += _control_OnControlStatusChanged;
        }

        public InternalOptionsControl(string featureOptionName, IServiceProvider serviceProvider)
            : base(serviceProvider)
        {
            _featureOptionName = featureOptionName;

            var panel = new StackPanel();
            this.AddOptions(panel);

            var viewer = new ScrollViewer();
            viewer.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
            viewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;

            var checkAllButton = new Button() { Content = "Check All" };
            checkAllButton.Click += (o, a) => panel.Children.OfType<CheckBox>().Do(c => c.IsChecked = true);

            var uncheckAllButton = new Button() { Content = "Uncheck All" };
            uncheckAllButton.Click += (o, a) => panel.Children.OfType<CheckBox>().Do(c => c.IsChecked = false);

            var selectionPanel = new StackPanel();
            selectionPanel.Children.Add(checkAllButton);
            selectionPanel.Children.Add(uncheckAllButton);

            panel.Children.Add(selectionPanel);

            viewer.Content = panel;

            this.Content = viewer;
        }

        public void Render(IUIContainer container)
        {
            _stackPanel = container.GetInterface<IStackPanel>();

            if (!_stackPanel.DisplaySummary)
            {
                if (_hasChildren == null) return;

                var scrollViewer = new ScrollViewer();
                var newStackPanel = new StackPanel();
                scrollViewer.Content = newStackPanel;
                scrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;

                var newStackPanelWrapper = new StackPanelWrapper(newStackPanel, scrollViewer, true);

                foreach (var child in _hasChildren.UIElements)
                {
                    if (child == null) continue;

                    child.Render(newStackPanelWrapper);
                }

                _stackPanel.AddChild(scrollViewer);

                var grid = (Grid) ((StackPanel) scrollViewer.Parent).Parent;
                var parent = (Window)grid.Parent;
                parent.SizeChanged += ParentSizeChanged;
            }
            else
            {
                if (_block.Parent != null)
                    ((StackPanel)_block.Parent).Children.Remove(_block);
                _stackPanel.AddChild(_block);
            }
        }

 public ClosableTabItem(string title, FrameworkElement image)
 {
     CloseableHeader closableTabHeader = new CloseableHeader();
     closableTabHeader.FileName.Content = title;
     closableTabHeader.close_button.Click += new System.Windows.RoutedEventHandler(close_button_Click);
     this.Header = closableTabHeader;
     ScrollViewer sv = new ScrollViewer();
     sv.HorizontalScrollBarVisibility = ScrollBarVisibility.Visible;
     sv.Loaded += new RoutedEventHandler(sv_Loaded);
     Canvas svContent = new Canvas();
     svContent.Background = Brushes.DarkGray;
     //svContent.MouseWheel += new MouseWheelEventHandler(sv_MouseWheel);
     sv.Content = svContent;
     Canvas viewPort = new Canvas();
     viewPort.Background = Brushes.White;
     viewPort.ClipToBounds = true;
     viewPort.MouseDown += new MouseButtonEventHandler(SelectItem);
     viewPort.LayoutTransform = newTransformations();
     viewPort.Children.Add(image);
     Canvas.SetTop(image, 0);
     Canvas.SetLeft(image, 0);
     image.Loaded += new RoutedEventHandler(image_Loaded);
     svContent.Children.Add(viewPort);
     this.Content = sv;
 }

		public SettingItemCanvas()
		{
			InitializeComponent();

			mItemrList = new List<Item>();

			canvas.Width = SettingItemButton.WIDTH;
			canvas.Height = SettingItemButton.HEIGHT * 7;
			canvas.Background = MetrialColor.getBrush(MetrialColor.Name.LightBlue, 0);
			setHeader();

			mSettingItemButtonScrollViewer = new ScrollViewer();
			mSettingItemButtonScrollViewer.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
			mSettingItemButtonScrollViewer.Width = SettingItemButton.WIDTH;
			mSettingItemButtonScrollViewer.Height = SettingItemButton.HEIGHT * 14;
			Canvas.SetTop(mSettingItemButtonScrollViewer, 100);
			Canvas.SetLeft(mSettingItemButtonScrollViewer, 50);
			canvas.Children.Add(mSettingItemButtonScrollViewer);

			mSettingItemButtonStackPanel = new StackPanel();
			mSettingItemButtonStackPanel.Orientation = Orientation.Vertical;
			mSettingItemButtonStackPanel.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
			Canvas.SetTop(mSettingItemButtonStackPanel, 0);
			Canvas.SetLeft(mSettingItemButtonStackPanel, 0);
			mSettingItemButtonScrollViewer.Content = mSettingItemButtonStackPanel;
			mSettingItemButtonStackPanel.Background = MetrialColor.getBrush(MetrialColor.Name.LightBlue, 0);

			updateSettingItemButton();
		}

		public OrderItemCanvas()
		{
			InitializeComponent();

			mOrderList = new List<Order>();

			canvas.Width = OrderItemButton.WIDTH;
			canvas.Height = OrderItemButton.HEIGHT * 7;

			setHeader();

			mOrderItemButtonScrollViewer = new ScrollViewer();
			mOrderItemButtonScrollViewer.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
			mOrderItemButtonScrollViewer.Width = OrderItemButton.WIDTH;
			mOrderItemButtonScrollViewer.Height = OrderItemButton.HEIGHT * 7;
			Canvas.SetTop(mOrderItemButtonScrollViewer, 50);
			Canvas.SetLeft(mOrderItemButtonScrollViewer, 0);
			canvas.Children.Add(mOrderItemButtonScrollViewer);

			mOrderItemButtonStackPanel = new StackPanel();
			mOrderItemButtonStackPanel.Orientation = Orientation.Vertical;
			mOrderItemButtonStackPanel.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
			Canvas.SetTop(mOrderItemButtonStackPanel, 0);
			Canvas.SetLeft(mOrderItemButtonStackPanel, 0);
			mOrderItemButtonScrollViewer.Content = mOrderItemButtonStackPanel;
		}

        protected override void OnInitialized(EventArgs e)
        {
            base.OnInitialized(e);
            initialized = true;
            ColumnDefinitions.Add(new ColumnDefinition ());
            ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(5) });
            ColumnDefinitions.Add(new ColumnDefinition());

            Children.Add(instances);
            instances.SelectionChanged += Instances_SelectionChanged;

            var splitter = new GridSplitter { Width = 5, HorizontalAlignment = HorizontalAlignment.Stretch };
            Children.Add(splitter);
            Grid.SetColumn(splitter, 1);
            Grid.SetRowSpan(splitter, 2);

            properties = new Properties { DataContext = null };
            var scrollViewer = new ScrollViewer {
                HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled,
                VerticalScrollBarVisibility = ScrollBarVisibility.Auto,
                Content = properties
            };
            Children.Add(scrollViewer);
            Grid.SetColumn(scrollViewer, 2);
            Update();
        }

 public override void OnApplyTemplate()
 {
     base.OnApplyTemplate();
     Scroll = (ScrollViewer)GetTemplateChild("Scroll");
     
     PreviewMouseWheel += StartMenu_MouseWheel;
 }

                public ContentPanel(string name, HeaderPanel headerPanel)
                {
                        //Setting properties
                        this.Height = Dimensions.GetHeight()*0.75;
                        this.Margin = new System.Windows.Thickness(0, 10, 0, 0);
                        this.Orientation = System.Windows.Controls.Orientation.Horizontal;

                        //Setting fields
                        RightPanelCoordinator coord = new RightPanelCoordinator(this);
                        _taskPanel = new TaskPanel(_detailsPanel,name,coord);        
                        _optionsPanel = new OptionsPanel(_taskPanel);                        

                        _rightPanel = _optionsPanel;
                        _firstLoad = true;
                        _isOnOptions = true;
                        _projectName = name;
                        _scroller = new ScrollViewer();
                        _headerPanel = headerPanel;

                        //Adding children
                        _scroller.Content = _taskPanel;
                        this.Children.Add(_scroller);
                        this.Children.Add(_rightPanel);

                        //Loading Brainstormings on beginning by default
                        LoadBrainstorming();
                }

        private void MainPage_Loaded(object sender, RoutedEventArgs e)
        {
            if (!viewModel.IsDataLoaded)
            {
                viewModel.LoadPhotosDown();
            }

            if (_alreadyHookedScrollEvents)
                return;

            _alreadyHookedScrollEvents = true;
            Photos.AddHandler(
                ManipulationCompletedEvent,
                (EventHandler<ManipulationCompletedEventArgs>)ListBox_ManipulationCompleted, true);

            _sv = (ScrollViewer)FindElementRecursive(Photos, typeof(ScrollViewer));

            if (_sv != null)
            {
                // Visual States are always on the first child of the control template 
                var element = VisualTreeHelper.GetChild(_sv, 0) as FrameworkElement;
                if (element != null)
                {
                    VisualStateGroup vgroup = FindVisualState(element, "VerticalCompression");
                    if (vgroup != null)
                    {
                        vgroup.CurrentStateChanging += vgroup_CurrentStateChanging;
                    }
                }
            }

        }