Control wird zum Teil nicht richtig dargestellt... Kann jemand helfen?

  • WPF

Es gibt 14 Antworten in diesem Thema. Der letzte Beitrag () ist von Nofear23m.

    Control wird zum Teil nicht richtig dargestellt... Kann jemand helfen?

    Hallo Leute und danke fürs reinschauen...

    Kennt jemand vielleicht das Problem mit den XAML, dass auf einmal zum Teil ein Control, den man selbst erstellt hat nicht mehr tut?

    Tag zuvor war alles ok. Dann habe ich einen neuen Control eingeführt, und seit dem werden andere Controls, bei denen ich nie bei war nicht mehr richtig dargestellt.

    Ich habe schon versucht den Control den ich als letzes eingeführt habe zu entfernen und alles neu zu erstellen. Hilft nicht...

    Kennt jemand eine Möglichkeit XAML Fehler zu sehen obwohl es kompiliert wird?

    Danke im Voraus.
    Doch schon, ich fürchte nur, dass mir welche gleich erzählen "wer macht den sowas"... Das Blöde ist, es hat sehr lange alles super funktioniert, und dann auf einmal nicht mehr.

    Vielleicht wäre es noch wichtig zu sagen, dass es sich um eine extra DLL handelt. Dort lege ich die Controls ab, die ich immer wieder verwende...

    XML-Quellcode

    1. ​<UserControl
    2. xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3. xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4. xmlns:d="http://schemas.microsoft.com/expression/blend/2008" Loaded="UserControl_Loaded"
    5. xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    6. mc:Ignorable="d" x:Class="csBase.Controls.csButton" PreviewMouseLeftButtonDown="TextBox_MouseLeftButtonDown"
    7. d:DesignWidth="200" d:DesignHeight="200" IsEnabledChanged="UserControl_IsEnabledChanged">
    8. <Grid IsEnabled="{Binding IsEnable}">
    9. <Border BorderBrush="{Binding csForeground}" BorderThickness="0.6" CornerRadius="2"/>
    10. <Border CornerRadius="2" Visibility="Hidden" Name="borIsSelected" Margin="0.6">
    11. <Border.Background>
    12. <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
    13. <GradientStop Color="LightGray" Offset="0"/>
    14. <GradientStop Color="WhiteSmoke" Offset="0.5"/>
    15. <GradientStop Color="LightGray" Offset="1"/>
    16. </LinearGradientBrush>
    17. </Border.Background>
    18. </Border>
    19. <TextBox Foreground="{Binding csForeground}" IsReadOnly="True" Text="{Binding csText}" FontSize="{Binding csTextSize}" VerticalContentAlignment="Center" VerticalAlignment="Stretch" Focusable="False" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center" Background="Transparent" BorderBrush="Transparent" Margin="5" TextWrapping="Wrap" FontFamily="Times New Roman"></TextBox>
    20. <Border BorderBrush="Gray" BorderThickness="2" Opacity="{Binding csOpacity}" CornerRadius="2">
    21. <Border.Background>
    22. <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
    23. <GradientStop Color="LightBlue" Offset="0"/>
    24. <GradientStop Color="WhiteSmoke" Offset="0.5"/>
    25. <GradientStop Color="LightBlue" Offset="1"/>
    26. </LinearGradientBrush>
    27. </Border.Background>
    28. </Border>
    29. </Grid>
    30. </UserControl>



    C#-Quellcode

    1. ​using System.Windows.Controls;
    2. using System.Windows.Input;
    3. using System.Timers;
    4. using System;
    5. using csBase.Classes;
    6. using System.Windows.Media;
    7. namespace csBase.Controls
    8. {
    9. public partial class csButton : UserControl
    10. {
    11. public csButton()
    12. {
    13. InitializeComponent();
    14. vViewItem.PropertyChanged += VViewItem_PropertyChanged;
    15. DataContext = vViewItem;
    16. }
    17. private void VViewItem_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    18. {
    19. if (e.PropertyName == "csIsSelected")
    20. {
    21. if (csSelectable)
    22. if (csIsSelected)
    23. borIsSelected.Visibility = System.Windows.Visibility.Visible;
    24. else
    25. borIsSelected.Visibility = System.Windows.Visibility.Hidden;
    26. }
    27. }
    28. private ViewItem _ViewItem = null;
    29. public ViewItem vViewItem
    30. {
    31. get
    32. {
    33. if (_ViewItem == null)
    34. _ViewItem = new ViewItem();
    35. return _ViewItem;
    36. }
    37. }
    38. public new object Tag
    39. {
    40. get
    41. {
    42. return vViewItem.Tag;
    43. }
    44. set
    45. {
    46. vViewItem.Tag = value;
    47. }
    48. }
    49. public bool csSelectable
    50. {
    51. get
    52. {
    53. return vViewItem.csSelectable;
    54. }
    55. set
    56. {
    57. vViewItem.csSelectable = value;
    58. }
    59. }
    60. public bool csIsSelected
    61. {
    62. get
    63. {
    64. return vViewItem.csIsSelected;
    65. }
    66. set
    67. {
    68. vViewItem.csIsSelected = value;
    69. }
    70. }
    71. public string csText
    72. {
    73. get
    74. {
    75. return vViewItem.csText;
    76. }
    77. set
    78. {
    79. vViewItem.csText = value;
    80. }
    81. }
    82. private void UserControl_IsEnabledChanged(object sender, System.Windows.DependencyPropertyChangedEventArgs e)
    83. {
    84. IsEnable = IsEnabled;
    85. }
    86. public bool IsEnable
    87. {
    88. get
    89. {
    90. return vViewItem.IsEnable;
    91. }
    92. set
    93. {
    94. vViewItem.IsEnable = value;
    95. }
    96. }
    97. public double csTextSize
    98. {
    99. get
    100. {
    101. return vViewItem.csTextSize;
    102. }
    103. set
    104. {
    105. vViewItem.csTextSize = value;
    106. }
    107. }
    108. public Brush csForeground
    109. {
    110. get
    111. {
    112. return vViewItem.csForeground;
    113. }
    114. set
    115. {
    116. vViewItem.csForeground = value;
    117. }
    118. }
    119. private Timer _timer = null;
    120. private Timer timer
    121. {
    122. get
    123. {
    124. if (_timer == null)
    125. {
    126. _timer = new Timer(50.0);
    127. _timer.Elapsed += _timer_Elapsed;
    128. }
    129. return _timer;
    130. }
    131. }
    132. private delegate void UpDelegate();
    133. private UpDelegate _udDelegate;
    134. private UpDelegate upDelegate
    135. {
    136. get
    137. {
    138. if (_udDelegate == null)
    139. _udDelegate = new UpDelegate(() =>
    140. {
    141. xx();
    142. });
    143. return _udDelegate;
    144. }
    145. }
    146. private void xx()
    147. {
    148. if (vViewItem.csOpacity > 0.1)
    149. vViewItem.csOpacity -= 0.1;
    150. else
    151. timer.Stop();
    152. }
    153. private void _timer_Elapsed(object sender, ElapsedEventArgs e)
    154. {
    155. try
    156. {
    157. if (System.Windows.Application.Current.Dispatcher.CheckAccess())
    158. xx();
    159. else
    160. System.Windows.Application.Current.Dispatcher.BeginInvoke(upDelegate);
    161. }
    162. catch (Exception ex)
    163. {
    164. csGlobalHelper.ShowError(ex);
    165. }
    166. }
    167. private void TextBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    168. {
    169. if (!IsEnable)
    170. return;
    171. vViewItem.csOpacity = 1;
    172. csClick?.Invoke(this);
    173. timer.Start();
    174. }
    175. public event Clicked csClick;
    176. public delegate void Clicked(csButton sender);
    177. private void UserControl_Loaded(object sender, System.Windows.RoutedEventArgs e)
    178. {
    179. Focusable = true;
    180. }
    181. public class ViewItem : csBaseItem
    182. {
    183. public ViewItem()
    184. {
    185. }
    186. private bool _IsEnable = true;
    187. public bool IsEnable
    188. {
    189. get
    190. {
    191. return _IsEnable;
    192. }
    193. set
    194. {
    195. if (_IsEnable == value)
    196. return;
    197. _IsEnable = value;
    198. OnPropertyChanged("IsEnable");
    199. }
    200. }
    201. private object _Tag = null;
    202. public object Tag
    203. {
    204. get
    205. {
    206. return _Tag;
    207. }
    208. set
    209. {
    210. _Tag = value;
    211. OnPropertyChanged("Tag");
    212. }
    213. }
    214. private string _csText = "";
    215. public string csText
    216. {
    217. get { return _csText; }
    218. set
    219. {
    220. if (_csText == value)
    221. return;
    222. _csText = value;
    223. OnPropertyChanged("csText");
    224. }
    225. }
    226. private double _csTextSize = 12;
    227. public double csTextSize
    228. {
    229. get
    230. {
    231. return _csTextSize;
    232. }
    233. set
    234. {
    235. if (_csTextSize == value)
    236. return;
    237. _csTextSize = value;
    238. OnPropertyChanged("csTextSize");
    239. }
    240. }
    241. private double _csOpacity = 0.0;
    242. public double csOpacity
    243. {
    244. get
    245. {
    246. return _csOpacity;
    247. }
    248. set
    249. {
    250. if (value < 0)
    251. value = 0;
    252. if (value > 1)
    253. value = 1;
    254. if (_csOpacity == value)
    255. return;
    256. _csOpacity = value;
    257. OnPropertyChanged("csOpacity");
    258. }
    259. }
    260. private bool _csSelectable = false;
    261. public bool csSelectable
    262. {
    263. get
    264. {
    265. return _csSelectable;
    266. }
    267. set
    268. {
    269. if (_csSelectable == value)
    270. return;
    271. _csSelectable = value;
    272. OnPropertyChanged("csSelectable");
    273. }
    274. }
    275. private bool _csIsSelected = false;
    276. public bool csIsSelected
    277. {
    278. get
    279. {
    280. return _csIsSelected;
    281. }
    282. set
    283. {
    284. if (_csIsSelected == value)
    285. return;
    286. _csIsSelected = value;
    287. OnPropertyChanged("csIsSelected");
    288. }
    289. }
    290. private Brush _csForeground = Brushes.Gray;
    291. public Brush csForeground
    292. {
    293. get
    294. {
    295. return _csForeground;
    296. }
    297. set
    298. {
    299. _csForeground = value;
    300. }
    301. }
    302. }
    303. }
    304. }


    Was mich ein wenig wundert, ist, dass früher ich den Border, der das ganze Blau übermalt beim Klicken nicht gesehen habe, und der Text hat sich geändert, wenn ich es irgend wo eingesetzt habe. Dann auf einmal nicht mehr. :(
    Hallo

    ​Es kann gar nicht sein das der Text sichtbar geht wenn dieser im XAML vor dem Border kommt.

    Statt

    XML-Quellcode

    1. <TextBox Foreground="{Binding csForeground}" IsReadOnly="True" Text="{Binding csText}" FontSize="{Binding csTextSize}" VerticalContentAlignment="Center" VerticalAlignment="Stretch" Focusable="False" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center" Background="Transparent" BorderBrush="Transparent" Margin="5" TextWrapping="Wrap" FontFamily="Times New Roman"></TextBox>
    2. <Border BorderBrush="Gray" BorderThickness="2" Opacity="{Binding csOpacity}" CornerRadius="2">
    3. <Border.Background>
    4. <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
    5. <GradientStop Color="LightBlue" Offset="0"/>
    6. <GradientStop Color="WhiteSmoke" Offset="0.5"/>
    7. <GradientStop Color="LightBlue" Offset="1"/>
    8. </LinearGradientBrush>
    9. </Border.Background>
    10. </Border>


    muss es so sein:

    XML-Quellcode

    1. <Border BorderBrush="Gray" BorderThickness="2" Opacity="{Binding csOpacity}" CornerRadius="2">
    2. <Border.Background>
    3. <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
    4. <GradientStop Color="LightBlue" Offset="0"/>
    5. <GradientStop Color="WhiteSmoke" Offset="0.5"/>
    6. <GradientStop Color="LightBlue" Offset="1"/>
    7. </LinearGradientBrush>
    8. </Border.Background>
    9. </Border>
    10. <TextBox Foreground="{Binding csForeground}" IsReadOnly="True" Text="{Binding csText}" FontSize="{Binding csTextSize}" VerticalContentAlignment="Center" VerticalAlignment="Stretch" Focusable="False" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center" Background="Transparent" BorderBrush="Transparent" Margin="5" TextWrapping="Wrap" FontFamily="Times New Roman"></TextBox>


    ​Ich kann die dein Beispiel gerne abändern denn so wie das jetzt aussieht geht du den völlig falschen weg. Soll jetzt keine Kritik sein. Ich wusste Anfangs auch nicht viel mit der WPF anzufangen, deshalb weis ich wie das ist.
    Gehe ich richtig der Annahme das es ein Button werden soll??

    ​Wenn ja, ein Button wo du die Transparenz, die Rahmenfarbe und die Textfarbe steuern können willst. Richtig?? Zumindest so wie ich den XAML verstehen. Du schreibst ja nicht was du erreichen willst. Da kann man nur raten.
    ​Wenn ja mach ich dir gerne ein Template. Das geht in der WPF nämlich viel einfacher und kann auch in einem UserConrol über DependencyProperties gelöst werden damit du dann auf diese (selbst erstellten) Eigenschaften Binden kannst.

    PS: Gewöhne dir an in einem Forum am besten nicht zu beschrieben was jetzt nicht geht, sondern besser was du erreichen willst. Oft macht man sich selbst das Leben schwer obwohl es einen einfacheren Weg ans Ziel gibt.

    Grüße
    ​Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Ja, das soll ein Button sein, der für Touchscreen gedacht ist. Der soll kurz die Farbe ändern nach einem Klick.

    Du sagst, dass es so nicht geht. Nun komisch, den wenn ich was in der selben DLL mache, dann sehe ich den Text. Wenn ich die DLL als Reference irgend wo hinzufüge, dann sehe ich nur einen Button ohne den Text. Und ich habe den Button sehr lange benutzt bevor es wie von alleine Kaput ging...

    Vielleicht hast du lust und Zeit mir so ein WPF teil zu basteln, dass ich mir das als Beispiel ansehen kann...
    Hallo

    ​Ganz kurz nur: Willst du wirklich das die Schrift erst sichtbar ist wenn der zweite Border eine Opacity von wenige als 1 hat?
    ​Das macht er nämlich in deinem Beispiel.

    ​Egal, ich mach mal einen Button, den kannst ja dann anpassen.

    Grüße
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Hallo

    ​Ich habe dir nun einen einfachen Style für solch einen Button erstellt. Mehr benötigt es nämlich gar nicht für das was du vor hast.
    Du musst dir nicht mal ein eigenes Usercontrol basteln.

    ​Ich war so frei und habe im zuge dessen gleich ein wenig Binding mit reingepackt. Vielleicht kommst du ja doch auf den Geschmack.
    ​Die eine Liste mit Buttons habe ich an eine Klasse gebunden. (ButtonDataList)
    ​Diese enthalt eine Liste von ButtonData, also die Buttons
    ​In der Klasse ButtonData sind die Properties wie Width, Height, Text usw. auf die die Buttons gebunden sind.

    ​Du kannst den Buttonstyle natürlich auch verwenden wie jeden anderen Button. Es ist ja einer und kein Usercontrol.
    ​Somit hast du ALLE Funktionalitäten eines Buttons aber mit der Optik die DU willst und er verhält sich somit wie sich ein Button verhalten soll. Das gilt auch z.b. für das Binden auf einen Command.

    Grüße
    Sascha

    Hier der Link: wetransfer.com/downloads/4213a…388a20170915151022/d92b50
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Bo, alter... bist aber echt schnell... Vielen Dank!

    Ich finde es gut, wie du es mir Zeigst... Dennoch hätte ich eine Frage zu dem ganzen. Ich habe jetzt deinen Beispiel ausprobiert, und der scheint irgend wie drauf zu reagieren, wenn man mit der Maus drüber geht und ändert seine Größe, wobei nach dem Klick er wieder größer wird....

    All das habe ich mittlerweile abgeschafft. Weil Touchscreen kennt kein MouseOver... Jedenfalls ist die Bedienung von Touchscreen etwas anders wie bei einem normalen Rechner... Jedenfalls die Maus.

    Was der Button macht ist eigentlich in ganz normale Sprache ausgedrückt so: Er wird angeklickt, ändert seine Farbe und geht langsam wieder zurück mit der Farbe in seinen Ursprung....

    Wenn du dir meinen Beispiel genauer ansiehst, so habe ich viel Aufwand betrieben dieses langsames zurück zu basteln. Es gibt dort einen Timer, ein Delegate usw. um das zu verwirklichen. Ich sage dir ganz ehrlich, selbst hier kriegen das nur wenige hin das alles durch Template zu ersetzen, sodass es von Eigenschaften sich gleich verhält.

    Versteh mich nicht falsch, ich traue es dir und vielen anderen durch aus zu, aber als ich vor dem Problem stand, ist mir leider nichts besseres eingefallen wie das was du siehst...

    Der Hintergrund für so etwas war ganz einfach. Du klickst irgend wie was an, und siehst nicht, dass du bereits geklickt hast...
    Hallo

    Ich muss dich leider korrigieren. Auch bei Touch kennt ein Button MouseOver und verändert sich beim klick. Wenn du das nicht haben willst nimm einfach im MyStatusBorderStyle folgende Zeilen raus:

    XML-Quellcode

    1. <DataTrigger Binding="{Binding IsMouseOver, RelativeSource={RelativeSource Self}}" Value="True">
    2. <Setter Property="Margin" Value="2" />
    3. </DataTrigger>


    Das mit der Farbe das die langsam zurück geht ist auch nicht schwer. Stichwort ist hier Animation und Storyboard.Hier mal vereinfachtes Beispiel:

    Ersetze im Projekt im MyTouchButtonStyle alle Style auf folgendes:

    XML-Quellcode

    1. <LinearGradientBrush x:Key="MyHoverBrush" EndPoint="0.5,1" StartPoint="0.5,0">
    2. <GradientStop Color="Blue" Offset="0"/>
    3. <GradientStop Color="White" Offset="0.5"/>
    4. <GradientStop Color="Blue" Offset="1"/>
    5. </LinearGradientBrush>
    6. <Style x:Key="MyStatusBorderStyle" TargetType="{x:Type Border}">
    7. <Setter Property="Background" Value="Transparent" />
    8. <Style.Triggers>
    9. <DataTrigger Binding="{Binding IsEnabled, RelativeSource={RelativeSource Self}}" Value="False">
    10. <Setter Property="Opacity" Value="0.3" />
    11. </DataTrigger>
    12. </Style.Triggers>
    13. </Style>
    14. <Style x:Key="MyNonStyleButton" TargetType="{x:Type Button}">
    15. <Setter Property="Padding" Value="2"/>
    16. <Setter Property="Margin" Value="4" />
    17. <Setter Property="Foreground" Value="{Binding Foreground, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type UserControl}}}"/>
    18. <Setter Property="Template">
    19. <Setter.Value>
    20. <ControlTemplate TargetType="{x:Type ButtonBase}">
    21. <Border x:Name="buttonBorder" Style="{StaticResource MyStatusBorderStyle}" Background="LightBlue" BorderBrush="Gray" BorderThickness="2" SnapsToDevicePixels="True">
    22. <Border.Triggers>
    23. <EventTrigger RoutedEvent="Border.MouseEnter">
    24. <EventTrigger.Actions>
    25. <BeginStoryboard>
    26. <Storyboard>
    27. <ColorAnimation AutoReverse="True" Duration="0:0:0.5" From="LightBlue" To="Blue" Storyboard.TargetName="buttonBorder"
    28. Storyboard.TargetProperty="(Border.Background).(SolidColorBrush.Color)">
    29. </ColorAnimation>
    30. </Storyboard>
    31. </BeginStoryboard>
    32. </EventTrigger.Actions>
    33. </EventTrigger>
    34. </Border.Triggers>
    35. <Border.Child>
    36. <ContentPresenter x:Name="contentPresenter" ContentTemplate="{TemplateBinding ContentTemplate}"
    37. Content="{TemplateBinding Content}" ContentStringFormat="{TemplateBinding ContentStringFormat}"
    38. HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" Margin="{TemplateBinding Padding}"
    39. RecognizesAccessKey="True" SnapsToDevicePixels="{TemplateBinding SnapsToDevicePixels}"
    40. VerticalAlignment="{TemplateBinding VerticalContentAlignment}"/>
    41. </Border.Child>
    42. </Border>
    43. </ControlTemplate>
    44. </Setter.Value>
    45. </Setter>
    46. </Style>


    Was passiert: Wenn die Maus über dem Border des ButtonTemplates ist wird das Storyboard mit der Coloranimation gestartet. Durch setzten des Properties Autoreverse der Coloranimation wird sichergestellt das die Animation wieder zurückläuft.


    PS: Wenn du sagst, du brauchst das nur beim klick und nicht beim Hover (wobei hover auch nicht schlecht ist falls es doch wer mit Maus bedient) dann kannst du folgende Zeile ersetzen:

    XML-Quellcode

    1. <EventTrigger RoutedEvent="Border.MouseEnter">


    Auf:

    XML-Quellcode

    1. <EventTrigger RoutedEvent="Border.TouchDown">


    Übrigens: Für Touch gibt es einen Haufen Events wie TouchEnter, TouchMove, ToucheLeave und TouchUp


    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Nofear23m“ ()

    Vielen Dank Sascha, läuft jetzt so wie ich es eigentlich haben wollte...

    Wobei es mehr abschreckt als das ganze schmackhaft macht. Trigger, Style usw. alles in WPF... Nun ja, wo lernt man so etwas vernümftig?

    Ich glaub ich bleibe ewig ein blöder Form-User... :(

    Super! Bist echt ein Gewinn für das Forum. Respekt.

    Jetzt hätte ich doch noch eine Frage:
    Mein Vorhaben ist es, solche Buttons und Labels die ich immer wieder benutze in einer DLL auszulagern, sodass eine BaseDLL gibt, die sich in jeden Projekt einbinden lässt. Der Hintergrund ist recht einfach, ich möchte das meine Programme von Style her alle gleich aussehen. Du hast es jetzt als Resourcen-Style wenn ich das so ausdrücken darf gemacht. Meine Frage ist es: Ist so was schwer in eine DLL auszulagern, sodass ich wie gewohnt im ToolBox den Button sehe und den einfach bei mir auf der Oberfläche einfügen kann? Verstehst du was ich meine?

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „EugenIS“ ()

    Hallo

    Danke für die Blumen. :P

    Ich kann mir vorstellen das du es so gewohnt bist. Ist in der WPF ganz einfach.

    Wenn du das ganze überall zur Verfügung haben willst kann du dir in einer DLL (damit zu alle Verweise in der Assembly hast leg am besten eine WPF Anwendung an und stelle dann im Eigenschaftenfenster des Projekts auf WPF-Klassenbibliothek um, is einfacher).
    In diesem Projekt legst du ein ResourceDictionary an und kopierst die ganzen Styles von mir hinein.

    In der Anwendung wo du die Styles und Templates dann verwenden willst musst du natürlich einen Verweis auf das Projekt mit den Styles haben.
    Dann kannst du z.b. wenn du es überall(!) in deinem Projekt zur Verfügung haben willst in der Application.xaml (app.xaml unter C# glaub ich) einen Import machen.

    XML-Quellcode

    1. <ResourceDictionary>
    2. <ResourceDictionary.MergedDictionaries>
    3. <ResourceDictionary Source="pack://application:,,,/deinAssembyDateiNameOhneEndung;component/deinResourceDictionary.xaml" />
    4. </ResourceDictionary.MergedDictionaries>
    5. </ResourceDictionary>
    6. <!--Workaround damit Styles übernommen werden welche in anderen dll`s eingebettet sind-->
    7. <Style TargetType="{x:Type Rectangle}" /> <!--Es muss mindestens ein Style vorhanden sein da sonst kein Style übernommen wird ;-)-->


    Ab da kannst du das Style überall Anwenden.

    Kleiner Tipp falls JEDER deiner Buttons so aussehen soll.
    Mach im Style folgendes. Nimm den Key "MyNonStyleButton" raus. also schaut die Zeile dann nur so aus:

    XML-Quellcode

    1. <Style TargetType="{x:Type Button}">


    Von da an musst du das Style auch nicht mehr angeben, sondern die WPF weis: OK ich hab einen Style für Button Allgemein, den muss ich jetzt überall anwenden wo kein anderes Style angegeben ist.
    Weist du einem Button explizit einen Style zu wird dieser vom Allgemeinen Buttonstyle ausgenommen.

    So, genug jetzt.
    PS: Ich habs per lerning by doing gelernt.

    ​Edit: Die Toolbox vergiss in der WPF gleich mal. Ich hab sie sogar geschlossen im VS. Braucht unter WPF kein Mensch.

    Schöne Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Hallo

    Sag, hat das jetzt funktioniert?
    Oder brauchst ein Beispiel?

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.
    Bin gerade dabei es zu implementieren und hätte eine Frage:

    du hast hier eine Animation und zwar ein Farbenverlauf von Leicht blau zu blau gemacht.

    Meine erste Frage: Ich würde es bevorzugen, wenn der Opacity von 1 auf 0 läuft. Wäre das möglich? Weil ich so den Border so gestalten kann wie ich es haben möchte...

    Und die Zweite frage: Ich klicke drauf, und schon ist das ganze geschehen... (Ich meine die Animation.) Ist es möglich, dass wenn ich drauf klicke und halte, dass der Border sichtbar ist, und nach dem loslassen so zusagen langsam verschwindet...

    Also ich muss echt sagen bin ein wenig überfordert mit dem ganzen. :(

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „EugenIS“ ()

    Hallo

    Also.... Das mit dem Border ist kein Problem mit der Opacity.

    Füge ein Storybord hinzu:

    XML-Quellcode

    1. <BeginStoryboard>
    2. <Storyboard>
    3. <DoubleAnimation Storyboard.TargetName="borderName"
    4. Storyboard.TargetProperty="Opacity"
    5. From="1"
    6. To="0"
    7. Duration="0:0:1"
    8. AutoReverse="True"
    9. RepeatBehavior="3x"/>
    10. </Storyboard>
    11. </BeginStoryboard>


    Wenn es nicht zurückgehen soll dann Autoreverse = False, der RepeatBehavior bewirkt das es 3x abläuft. Also in Kombi mit dem Autoreverse würde es 3x pulsieren. "borderName" ist der Name deines Borders.

    Das zweite geht auch. Ich glaube (hab den Code nicht vor mir) ich hatte die Animation zum Event "Click" starten lassen. und hatte Autoreverse drinnen. Willst du das selbst steuern so wie du schreibst dann nehme das Autoreverse raus und legst das Event auf MouserOver fest.
    Dann kopierst du die Animation und machst das ganze genau anders rum (die werte der Coloranimation tauschen) mit MouseLeave.

    Falls du Hilfe brauchst sags nur, bin aber erst morgen Abend wieder vor einem Rechner.

    So, jetzt muss ich dann auch schon, muss morgen in der früh gleich mal 400km fahren.

    Grüße
    Sascha
    If _work = worktype.hard Then Me.Drink(Coffee)
    Seht euch auch meine Tutorialreihe <WPF Lernen/> an oder abonniert meinen YouTube Kanal.