I'm using WPF-NotifyIcon, and am following this tutorial, and it works when I put the XAML code in my MainWindow.xaml, however once I move onto the "Creating the NotifyIcon from a Resource Dictionary" part it stops showing up in the tray.
I have a Dictionary1.xaml with the following code in it:
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:tb="http://www.hardcodet.net/taskbar">
<!-- Globally declared notify icon -->
<tb:TaskbarIcon x:Key="MyNotifyIcon"
IconSource="/Notifier;component/assets/icon_16x.ico"
ToolTipText="Notifier" MenuActivation="RightClick" Visibility="Visible" />
</ResourceDictionary>
An App.xaml with the following code:
<Application x:Class="Notifier.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
StartupUri="MainWindow.xaml">
<Application.Resources>
<ResourceDictionary Source="Dictionary1.xaml" />
</Application.Resources>
</Application>
and I just copied over the App class code from that section of the tutorial.
What am I doing wrong? Why isn't the icon showing up? And on a related note, how can I have a program that doesn't have a MainWindow, but instead just runs from the taskbar (Which would be ideal with this control).
Edit:
I took out the StartupUri from App.xaml and put the following code in my App.xaml.cs:
protected override void OnStartup(StartupEventArgs e) {
base.OnStartup(e);
tb = (TaskbarIcon)FindResource("MyNotifyIcon");
tb.Visibility = Visibility.Visible;
//new MyClassIWantToInstantiate();
}
It works perfectly, but is there anything wrong with doing this?
You should be adding that ResourceDictionary to the MergedDictionaries section if you want to use the resources normally.
Example:
<Application x:Class="Notifier.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
StartupUri="MainWindow.xaml">
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Dictionary1.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
</Application>
Ran into the same when I was following the tutorial on https://www.codeproject.com/Articles/36468/WPF-NotifyIcon-2#hello
The text indicates that you should instantiate your taskbarIcon within Initapplication() which did not work for me.
From the tutorial:
private void InitApplication()
{
//initialize NotifyIcon
tb = (TaskbarIcon) FindResource("MyNotifyIcon");
}
However, when looking at the included Samples it's done in the OnStartup override which seems to make more sense to me.
The following works as expected.
private TaskbarIcon tb;
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
//create the notifyicon (it's a resource declared in NotifyIconResources.xaml
tb = (TaskbarIcon)FindResource("MyNotifyIcon");
}
Related
I want to achieve themes in my WPF program.
I stored the color in the database and then load it into MergedDictionaries.
Here are my codes:
<Application x:Class="Test"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:Test"
StartupUri="MainWindow.xaml">
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
</Application>
And here are code-behind:
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.IO;
using System.Linq;
using System.Resources;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Media;
using System.Windows.Resources;
namespace Test
{
/// <summary>
/// Interaction logic for App.xaml
/// </summary>
public partial class App : Application
{
public App()
{
ChangeTheme("Dark");
}
public ResourceDictionary ThemeDictionary
{
get { return Resources.MergedDictionaries[0]; }
}
public void ChangeTheme(string ThemeName)
{
Resources.MergedDictionaries.Clear();
Resources.MergedDictionaries.Add(new ResourceDictionary());
///some logic to load color from database
ThemeDictionary.Add("NormalBackground",new SolidColorBrush(Colors.Red));
}
}
}
And here are sample of front-end:
<Window x:Class="Test"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:Test"
mc:Ignorable="d"
Height="450" Width="800">
<Grid Background="{StaticResource NormalBackground}">
</Grid>
</Window>
After the program ran. VS reports error that cannot find StaticResource "NormalBackground".
Whereas, if I add an exist ResourceDictionary into the MergedDictionaries, all works well.
What's wrong with my code? Thank you.
You are calling "ChangeTheme("Dark")" too early. It should be called from within OnStartup in App.xaml.cs. I guess that the resource dictionaries defined in the xaml (which is empty in your case) will overwrite everything you put in there by code in your constructor.
public App()
{
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
ChangeTheme("Dark");
}
Also, you can remove the inner part of your MergedDictionaries from you App.xaml
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
According to the logic of work in the current implementation, you first set your dictionary in the App constructor. After that, the XAML is initialized. Upon XAML initialization, the <ResourceDictionary> tag creates a new dictionary and stores it in App.Resources. This action removes the instance you created in the constructor.
Therefore, when the UserControl is called, the App only has an empty dictionary in which your resource does not exist.
For your implementation to work properly, you should remove the <Application.Resources> section entirely from the XAML.
<Application x:Class="Test"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:Test"
StartupUri="MainWindow.xaml">
<!-- <Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>-->
</Application>
As others have suggested, replacing StaticResource with DynamicResource is not a solution, as there is no resource itself with the specified key.
DynamicResource can help if you replace the resource pointed to by DynamicResource or the dictionary with this resource at runtime.
I was going through some code in our product and saw some colleagues using ResourceDictionary.MergedDictionaries in a way I had not seen it used before:
<UserControl.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<toolTips:ToolTips />
<styles:ControlStyles />
<icons:IconDictionary />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</UserControl.Resources>
tooltips:ToolTips and all the other elements in the MergedDictionaries are ResourceDictionaries.
The regular way of using these according to the internet is to use <ResourceDictionary Source="uri to your xaml file"/>.
So is there any practical difference between both?
If this way works why isn't it used more often as it plays well with code completion?
I've used ResourceDicionary this way only once on a big project and it was benefical in my situation.
Suppose that you have ResourceDictionary in MyDictionary.xaml file.
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
x:Class="YourNamespace.MyDictionary">
</ResourceDictionary>
You can add an x:Class attribute to the ResourceDictionary element and specify the fully qualified name of the code-behind class.
Let's create MyDictionary.xaml.cs with class MyDictionary (name can be different from the name of the xaml file).
public partial class MyDictionary
{
public MyDictionary()
{
InitializeComponent();
}
}
A class must be a partial class. The constructor must be added to the class and InitializeComponent method must be called. The InitializeComponent method will be automatically generated for the class if you set the x:Class attribute in MyDictionary.xaml
Now you can reference MyDictionary in MergedDictionaries
<Window.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<local:MyDictionary/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Window.Resources>
If you add some DataTemplate into MyDictionary.xaml you can create event handlers in code-behind (handlers will be automatically generated by VS)
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
x:Class="YourNamespace.MyDictionary">
<DataTemplate x:Key="MyTemplate">
<Button Click="Button_Click"/>
</DataTemplate>
</ResourceDictionary>
Code-behind:
public partial class MyDictionary
{
public MyDictionary()
{
InitializeComponent();
}
private void Button_Click(object sender, System.Windows.RoutedEventArgs e)
{
// custom logic
// edit another element, etc.
}
}
If the class is inherited from the ResourceDictionary class then other resources can be accessed from the code-behind.
Example of usage of data template defined in MyDictonary:
<Window.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<local:MyDictionary/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Window.Resources>
<Grid>
<ContentControl ContentTemplate="{StaticResource MyTemplate}"/>
</Grid>
From my point of view the biggest advantages are that you can encapsulate logic into separated files (it's easy to maintain and add new features in big projects) and avoid referencing ResourceDictionaries by <ResourceDictionary Source="uri to your xaml file"/>.
I'm trying to split up a ResourceDictionary containing styles for multiple controls in our current UWP application. The file has grown to about 3000 lines and has become a living hell to manage, so I decided to split it up into smaller, more specific ResourceDictionaries and include them using MergedDictionaries.
App.xaml
<common:BootStrapper x:Class="Asteria.Ion.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:common="using:Template10.Common"
xmlns:styles="using:Asteria.Ion.Styles"
RequestedTheme="Dark">
<common:BootStrapper.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Styles\Custom.xaml" />
<ResourceDictionary Source="Styles\CustomControls.xaml" />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</common:BootStrapper.Resources>
</common:BootStrapper>
CustomControls.xaml contains references to other ResourceDictionaries.
<ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:controls="using:Template10.Controls"
xmlns:behaviors="using:Template10.Behaviors"
xmlns:interactivity="using:Microsoft.Xaml.Interactivity"
xmlns:local="using:Asteria.Ion.Styles">
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Shared.xaml" />
<ResourceDictionary Source="Templates.xaml" />
<ResourceDictionary Source="ComponentBlock.xaml" />
<ResourceDictionary Source="FlowAgent.xaml" />
<ResourceDictionary Source="Planning.xaml" />
<ResourceDictionary Source="ProjectDialog.xaml" />
<ResourceDictionary Source="Inspector.xaml" /-->
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
This will always produce the following exception:
Failed to assign to property 'Windows.UI.Xaml.ResourceDictionary.Source' because the type 'Windows.Foundation.String' cannot be assigned to the type 'Windows.Foundation.Uri'. [Line: 12 Position: 37]
I've tried changing the source URI numerous times, but it keeps giving this error. Only commenting out all the ResourceDictionary elements in CustomControls.xaml helps. But then I get exceptions concerning missing styles of course.
Some URI formats I've tried:
/Styles/Shared.xaml
Styles/Shared.xaml
Styles\Shared.xaml
.\Shared.xaml
ms-appx:///Styles/Shared.xaml
None of them work.
Any advice would be appreciated.
In the end it had nothing to do with the URI structure, but with a combination of ThemeDictionaries and MergedDictionaries.
What was working before:
In App.Resources:
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Styles/Themes.xaml" />
<ResourceDictionary Source="Styles/CustomControls.xaml" />
</ResourceDictionary.MergedDictionaries>
Where Themes.xaml contained ThemeDictionaries and CustomControls.xaml contained <Styles> ( a lot of them ).
After splitting CustomControls.xaml, it no longer contained any styles, but only MergedDictionaries.
Looking something like this:
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="ControlStyles/ProjectDialog.xaml" />
<ResourceDictionary Source="ControlStyles/Inspector.xaml" />
</ResourceDictionary.MergedDictionaries>
Inspector.xaml contained a Style using {ThemeResource} and it appears that's where it went wrong. The solution/work-around in the end was to include a MergedDictionaries with a references to Themes.xaml in Inspector.xaml.
Now if anyone can explain the exact reasoning behind this solution, I'd be much obliged.
From the error message,XAML Compiler failed to translate the Source Property of nested ResourceDictionaries. The easiest and fastest workaround is to add the nested ResourceDictionaries in App.Xaml.cs:
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
...
var applicationMergedDics = Application.Current.Resources.MergedDictionaries;
applicationMergedDics[0].MergedDictionaries.Add(new ResourceDictionary() { Source = new Uri("ms-appx:///Styles/Shared.xaml") });
applicationMergedDics[0].MergedDictionaries.Add(new ResourceDictionary() { Source = new Uri("ms-appx:///Styles/Templates.xaml") });
...
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
Notes: Don't forget to remove the MergedDictionaries in CustomControls.xaml. And the error will be gone.
I've came across this error, which I couldn't find the solution for. I'm implementing an mvvm application and in main window I'm setting the main DataContext in xaml using a loader:
in App.xaml:
<Application.Resources>
<viewModel:KinectViewModelLoader x:Key="KinectViewModelLoader"/>
</Application.Resources>
In MainWindow.xaml:
<Window x:Class="KinectFittingRoom.MainWindow"
...
DataContext="{Binding KinectViewModel, Source={StaticResource KinectViewModelLoader}}">
...
</Window>
Everything was running well, but now I wanted to add some dynamic resources, so I've created some xaml files containing styles and other elements.
In example:
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<ModelUIElement3D x:Key="BirthdayHatModel">
...
</ModelUIElement3D>
</ResourceDictionary >
To use them in MainWindow.xaml I've added them to App.xaml file as ResourceDirectory and then my application began to crash.
App.xaml:
<Application x:Class="KinectFittingRoom.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:viewModel="clr-namespace:KinectFittingRoom.ViewModel"
StartupUri="MainWindow.xaml">
<Application.Resources>
<viewModel:KinectViewModelLoader x:Key="KinectViewModelLoader"/>
<ResourceDictionary x:Key="ResourceDictionary">
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Resources/Styles/GlassButton.xaml"/>
<ResourceDictionary Source="Resources/Models/BirthdayHat.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
</Application>
And now I'm getting an error on App.xaml.cs file saying that KinectFittingRoom.App.OnExit(System.Windows.ExitEventArgs) has no suitable method to override.
My overriden method:
protected override void OnExit(ExitEventArgs e)
{
KinectViewModelLoader.Cleanup();
base.OnExit(e);
}
Mabe someone could explain to me why adding ResourceDirectory node causes my application to throw an error? What can I do to include those resources and avoid such problem? I would appreciate any advice.
I think you need to change two things in your XAML:
In your App.xaml file Move the declaration of your ViewModel inside ResourceDictionary section. Also if possible you should delete x:Key="ResourceDictionary". So now your App.xaml should look like:
<Application x:Class..................>
<Application.Resources>
<ResourceDictionary>
<viewModel:KinectViewModelLoader x:Key="KinectViewModelLoader"/>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Resources/Styles/GlassButton.xaml"/>
<ResourceDictionary Source="Resources/Models/BirthdayHat.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
</Application>
If after following the above step your program does not work then please follow this step along. Change the DataContext Property of your window like the code shown below:
<Window x:Class="KinectFittingRoom.MainWindow"
DataContext="{StaticResource KinectViewModelLoader}">
...
</Window>
If still your application does not work then change the order of the lines in App.OnExit() as follows:
protected override void OnExit(ExitEventArgs e)
{
base.OnExit(e);
KinectViewModelLoader.Cleanup();
}
I have the following App.xaml file:
<Application x:Class="MiniDeviceConfig.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
StartupUri="MiniDeviceConfig.xaml">
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Button.xaml"/>
<ResourceDictionary Source="CheckBox.xaml"/>
<ResourceDictionary Source="ComboBox.xaml"/>
<ResourceDictionary Source="Common.xaml"/>
<ResourceDictionary Source="GroupBox.xaml"/>
<ResourceDictionary Source="Label.xaml"/>
<ResourceDictionary Source="LinkButton.xaml"/>
<ResourceDictionary Source="ListBox.xaml"/>
<ResourceDictionary Source="ListView.xaml"/>
<ResourceDictionary Source="RadioButton.xaml"/>
<ResourceDictionary Source="Tooltip.xaml"/>
<ResourceDictionary Source="Window.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
In my application, my main window is MiniDeviceConfig.xaml (as seen above). In my Button.xaml file, I clearly set the button height to some obscene number. And, this size is reflected in my main window's buttons. However, some action on the main window triggers a modal window that has more buttons on it. I was expecting the same tall buttons but no such luck. How do I get the style to propagate into all windows in the application?
You can try very helpful class ThemeManager from http://wpfthemes.codeplex.com. In our project we had similiar problems and solve it by using it.
Figured it out. There were other resources included that were conflicting.