동동이의 블러그

 DependencyObject ucParent = _parent.Parent;
            while (!(ucParent is UserControl))
            {
                ucParent = LogicalTreeHelper.GetParent(ucParent);
            }


하위 UserControl에서 상위 UserControl의 Owner 찾는법

참조 : http://stackoverflow.com/questions/1474438/wpf-get-usercontrol-owner

페이지가 여러개 있을때 페이지 넘기는 효과를 준다. 여러가지 type이 있다.

ContentTemplateSelector가 변경되었을때 이벤트를 이용하기때문에 TempleteSelector를 만들어야 한다.


샘플 파일 

PageAnimation.zip



사용법 Xaml

<local:AnimatedContentControl AnimationDuration="0:0:1.0" Content="{Binding NavigationState}" AnimateType="Right" Height="200" ContentTemplateSelector="{DynamicResource MainTemplateSelector}">            
</local:AnimatedContentControl>

TemplateSelector.cs

public class MainTemplateSelector : DataTemplateSelector
    {
        public DataTemplate TestTemplate { get; set; }
        public DataTemplate LoadingTemplate { get; set; }
        public MainTemplateSelector()
        {
        }
        public override DataTemplate SelectTemplate(object item, DependencyObject container)
        {
            if ((item as string) == "Loading")
            {
                return LoadingTemplate;
            }
            else
            {
                return TestTemplate;
            }
            return base.SelectTemplate(item, container);
        }
    }


AnimationContentControl.cs
 public enum AnimateType
    {
        Right,
        Top,
        Down,
        Left,
        Opacity,
    }
    /// <summary>
    /// A ContentControl that animates the transition between content
    /// </summary>
    [TemplatePart(Name = "PART_PaintArea", Type = typeof(Shape)),
     TemplatePart(Name = "PART_MainContent", Type = typeof(ContentPresenter))]
    public class AnimatedContentControl : ContentControl
    {
        public AnimateType AnimateType
        {
            get { return (AnimateType)GetValue(AnimateTypeProperty); }
            set { SetValue(AnimateTypeProperty, value); }
        }
        // Using a DependencyProperty as the backing store for AnimateType.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty AnimateTypeProperty =
            DependencyProperty.Register("AnimateType", typeof(AnimateType), typeof(AnimatedContentControl), new PropertyMetadata(AnimateType.Left));
        #region Generated static constructor
        static AnimatedContentControl()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(AnimatedContentControl), new FrameworkPropertyMetadata(typeof(AnimatedContentControl)));
        }
        #endregion Generated static constructor
        public TimeSpan AnimationDuration
        {
            get { return (TimeSpan)GetValue(AnimationDurationProperty); }
            set { SetValue(AnimationDurationProperty, value); }
        }
        // Using a DependencyProperty as the backing store for AnimationDuration.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty AnimationDurationProperty =
            DependencyProperty.Register("AnimationDuration", typeof(TimeSpan), typeof(AnimatedContentControl), new PropertyMetadata(TimeSpan.FromSeconds(0.5)));
        public IEasingFunction EasingFunction
        {
            get { return (IEasingFunction)GetValue(EasingFunctionProperty); }
            set { SetValue(EasingFunctionProperty, value); }
        }
        // Using a DependencyProperty as the backing store for EasingFunction.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty EasingFunctionProperty =
            DependencyProperty.Register("EasingFunction", typeof(IEasingFunction), typeof(AnimatedContentControl), new PropertyMetadata(new PowerEase() { EasingMode = EasingMode.EaseInOut }));
        private Shape m_paintArea;
        private ContentPresenter m_mainContent;
        /// <summary>
        /// This gets called when the template has been applied and we have our visual tree
        /// </summary>
        public override void OnApplyTemplate()
        {
            m_paintArea = Template.FindName("PART_PaintArea", this) as Shape;
            m_mainContent = Template.FindName("PART_MainContent", this) as ContentPresenter;
            base.OnApplyTemplate();
        }
        protected override void OnContentTemplateSelectorChanged(DataTemplateSelector oldContentTemplateSelector, DataTemplateSelector newContentTemplateSelector)
        {
            base.OnContentTemplateSelectorChanged(oldContentTemplateSelector, newContentTemplateSelector);
            if (ContentTemplateSelector != null)
            {
                ContentTemplate = ContentTemplateSelector.SelectTemplate(Content, null);
            }
        }
        protected override void OnContentTemplateChanged(DataTemplate oldContentTemplate, DataTemplate newContentTemplate)
        {
            base.OnContentTemplateChanged(oldContentTemplate, newContentTemplate);
        }
        /// <summary>
        /// This gets called when the content we're displaying has changed
        /// </summary>
        /// <param name="oldContent">The content that was previously displayed</param>
        /// <param name="newContent">The new content that is displayed</param>
        protected override void OnContentChanged(object oldContent, object newContent)
        {
            if (m_paintArea != null && m_mainContent != null)
            {
                m_paintArea.Fill = CreateBrushFromVisual(m_mainContent);
                BeginAnimateContentReplacement();
            }
            if (ContentTemplateSelector != null)
            {
                ContentTemplate = ContentTemplateSelector.SelectTemplate(newContent, null);
            }
            base.OnContentChanged(oldContent, newContent);
        }
        /// <summary>
        /// Starts the animation for the new content
        /// </summary>
        private void BeginAnimateContentReplacement()
        {
            var newContentTransform = new TranslateTransform();
            var oldContentTransform = new TranslateTransform();
            m_paintArea.RenderTransform = oldContentTransform;
            m_mainContent.RenderTransform = newContentTransform;
            m_paintArea.Visibility = Visibility.Visible;
            switch (AnimateType)
            {
                case AnimateType.Top:
                    newContentTransform.BeginAnimation(TranslateTransform.YProperty, CreateAnimation(-this.ActualHeight, 0));
                    oldContentTransform.BeginAnimation(TranslateTransform.YProperty, CreateAnimation(0, this.ActualHeight, (s, e) => m_paintArea.Visibility = Visibility.Hidden));
                    break;
                case AnimateType.Down:
                    newContentTransform.BeginAnimation(TranslateTransform.YProperty, CreateAnimation(this.ActualHeight, 0));
                    oldContentTransform.BeginAnimation(TranslateTransform.YProperty, CreateAnimation(0, -this.ActualHeight, (s, e) => m_paintArea.Visibility = Visibility.Hidden));
                    break;
                case AnimateType.Left:
                    newContentTransform.BeginAnimation(TranslateTransform.XProperty, CreateAnimation(-this.ActualWidth, 0));
                    oldContentTransform.BeginAnimation(TranslateTransform.XProperty, CreateAnimation(0, this.ActualWidth, (s, e) => m_paintArea.Visibility = Visibility.Hidden));
                    break;
                case AnimateType.Right:
                    newContentTransform.BeginAnimation(TranslateTransform.XProperty, CreateAnimation(this.ActualWidth, 0));
                    oldContentTransform.BeginAnimation(TranslateTransform.XProperty, CreateAnimation(0, -this.ActualWidth, (s, e) => m_paintArea.Visibility = Visibility.Hidden));
                    break;
                case AnimateType.Opacity:
                    m_mainContent.BeginAnimation(UIElement.OpacityProperty, CreateAnimation(0, 1));
                    m_paintArea.BeginAnimation(UIElement.OpacityProperty, CreateAnimation(1, 0, (s, e) => m_paintArea.Visibility = Visibility.Hidden));
                    break;
                default:
                    break;
            }
        }
        /// <summary>
        /// Creates the animation that moves content in or out of view.
        /// </summary>
        /// <param name="from">The starting value of the animation.</param>
        /// <param name="to">The end value of the animation.</param>
        /// <param name="whenDone">(optional) A callback that will be called when the animation has completed.</param>
        private AnimationTimeline CreateAnimation(double from, double to, EventHandler whenDone = null)
        {
            var anim = new DoubleAnimation(from, to, AnimationDuration) { EasingFunction = EasingFunction };
            if (whenDone != null)
                anim.Completed += whenDone;
            anim.Freeze();
            return anim;
        }
        /// <summary>
        /// Creates a brush based on the current appearnace of a visual element. The brush is an ImageBrush and once created, won't update its look
        /// </summary>
        /// <param name="v">The visual element to take a snapshot of</param>
        private Brush CreateBrushFromVisual(Visual v)
        {
            if (v == null)
                throw new ArgumentNullException("v");
            var target = new RenderTargetBitmap((int)this.ActualWidth, (int)this.ActualHeight, 96, 96, PixelFormats.Pbgra32);
            target.Render(v);
            var brush = new ImageBrush(target) { AlignmentY = AlignmentY.Top, Stretch = Stretch.None };
            brush.Freeze();
            return brush;
        }
    }

Usercontrol등 Element등을 캡쳐 할수 있도록 만들었다.

용도는 캠 이미지위에 배경및 각종 clip art들을 얹혀서 캡쳐 하기위한 용도~


 public static string SaveCamCapture(string filePath, FrameworkElement targetControl)
        {
            targetControl.UpdateLayout();
            // Get the size of the Visual and its descendants.
            Rect rect = VisualTreeHelper.GetDescendantBounds(targetControl);
            // Make a DrawingVisual to make a screen
            // representation of the control.
            DrawingVisual dv = new DrawingVisual();
            // Fill a rectangle the same size as the control
            // with a brush containing images of the control.
            using (DrawingContext ctx = dv.RenderOpen())
            {
                VisualBrush brush = new VisualBrush(targetControl);
                ctx.DrawRectangle(brush, null, new Rect(rect.Size));
            }
            RenderTargetBitmap targetBitmap = new RenderTargetBitmap((int)(targetControl.ActualWidth), (int)(targetControl.ActualHeight), 96, 96, PixelFormats.Pbgra32);
            targetBitmap.Render(dv);
            var bitmapEncoder = new PngBitmapEncoder();
            bitmapEncoder.Frames.Add(BitmapFrame.Create(targetBitmap));
            if (filePath != null)
            {
                using (var filestream = new FileStream(filePath, FileMode.Create))
                {
                    bitmapEncoder.Save(filestream);
                }
            }
            return filePath;
        }

ImageButton.cs

스타일

<Style TargetType="{x:Type c:ImageButton}">

        <Setter Property="Template">

            <Setter.Value>

                <ControlTemplate TargetType="{x:Type c:ImageButton}">

                    <Border x:Name="buttonBorder">

                        <Border.Effect>

                            <DropShadowEffect Opacity="0.0" />

                        </Border.Effect>

                        <Image  Source="{TemplateBinding NormalImage}" x:Name="img" />

                    </Border>

                    <ControlTemplate.Triggers>

                        <Trigger Property="IsPressed" Value="true">

                            <Setter TargetName="img" Property="Source" Value="{Binding PressImage, RelativeSource={RelativeSource TemplatedParent}}" />

                        </Trigger>

                    </ControlTemplate.Triggers>

                </ControlTemplate>

            </Setter.Value>

        </Setter>

    </Style>

사용예 :

<c:ImageButton x:Name="xStartBtn" Width="300" Height="300" Content="Start" NormalImage="/CartoonMuseum;component/Images/sampleBtn.png" PressImage="/CartoonMuseum;component/Images/samplePressBtn.png" />

Themes/Generic.xaml

     <Style TargetType="{x:Type c:ImageButton}">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="{x:Type c:ImageButton}">
                    <Border Name="buttonBorder">
                        <Border.Effect>
                            <DropShadowEffect Opacity="0.0" />
                        </Border.Effect>
                        <Border.Child>
                            <Image  Source="{TemplateBinding NormalImage}" x:Name="img" />
                        </Border.Child>
                    </Border>
                    <ControlTemplate.Triggers>
                        <Trigger Property="IsPressed" Value="true">
                            <Setter TargetName="img" Property="Source" Value="{Binding PressImage, RelativeSource={RelativeSource TemplatedParent}}" />
                        </Trigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>

ImageButton.cs

 public class ImageButton : Button
    {
        public ImageSource NormalImage
        {
            get { return base.GetValue(NormalImageProperty) as ImageSource; }
            set { base.SetValue(NormalImageProperty, value); }
        }
        public static readonly DependencyProperty NormalImageProperty =
          DependencyProperty.Register("NormalImage", typeof(ImageSource), typeof(ImageButton));
        public ImageSource PressImage
        {
            get { return base.GetValue(PressImageProperty) as ImageSource; }
            set { base.SetValue(PressImageProperty, value); }
        }
        public static readonly DependencyProperty PressImageProperty =
          DependencyProperty.Register("PressImage", typeof(ImageSource), typeof(ImageButton));
        public ImageButton()
        {
            DefaultStyleKey = typeof(ImageButton);
        }
        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
        }
    }

PC에서는 잘나오지만 태블릿 해상도에서는 짤려서 나와서

처방을 한 코드

loaded 이벤트
root.Width = 1920;
root.Height = this.ActualHeight / this.ActualWidth * 1920;
xaml 디자인 
<Viewbox>        <Grid x:Name="root">

웹캠 라이브러리는 사람들이 많이 쓰는 Aforge를 사용하였다.

문제는 웸캠 위에 이미지를 덫 씌워야 하는데 워터마크 처럼

그게 일반적인 방법으로는 안되서

 Drawing.Image image = Drawing.Image.FromFile("ct.png");

            System.Windows.Forms.PictureBox pic = new System.Windows.Forms.PictureBox()

            {

                Image = image,

                Height = 300,

                Width = 300,

                BackColor = Color.Transparent,

                SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage

            };

            VideoSourcePlayer.Controls.Add(pic);

보니까 이렇게 Controls에 add할수 있는게 있었다.

아쉽게도 windowsformshost를 사용하기 떄문에 picturebox를 이용하여야하고 투명으로 직접 설정해줘야 한다.

그러면 이렇게 된다.

소스는 여기에

WebcamTest.zip