I'm trying to add https://modernuicharts.codeplex.com/ WPF project into my solution.
I extracted the projects that was needed for wpf
Library - De.TorstenMandelkow.MetroChart.WPF
TestApplications - TestApplication.Shared
- TestApplicationWPF
De.TorstenMandelkow.MetroChart
I right clicked my current solutions and I went to Add -> Add Existing project and added the above projects.
When I set TestAplicationWPF as start up Project, the Project runs completely fine.
My goal is to have a button which will display Modern UI Charts Interface in my other project called "WPF".
WPF - ViewModel
//Button Code
public MainWindow ShowModernUI()
{
return new TestApplicationWPF.MainWindow();
}
It returns this error A first chance exception of type 'System.Windows.Markup.XamlParseException' occurred in PresentationFramework.dll
I checked the inner exception and it gave me "Cannot find resource named 'PageContent' which corresponds to TestAplicationWPF.MainWindow.xaml code
TestAplicationWPF.MainWindow.xaml
<ContentControl Content="{Binding}" VerticalAlignment="Stretch" HorizontalAlignment="Stretch" ContentTemplate="{StaticResource PageContent}" />
Page Content is from a resource Dictionary within TestAplicationWPF.
My attempt to fix the problem was to create a copy of the resource dictionary within my "WPF" project and it removed the error but nothing shows. May I ask how do I display the MainWindow from TestApplicationWPF
Here's how to fix it:
There are few issues with the library, there used to be a Nuget package but it has been unlisted so I'll show you how to compile and reference the library in your WPF app.
download the file SourceAndTestApplications.zip by clicking Download on the right
extract the MetroChart folder somewhere and open the MetroChart.sln inside it
If you are using VS2013 the following screen will appear:
Nothing to worry about, just press OK and close the Migration Report it opened in IE
Again, if you are under Windoww 8.1, the following will appear:
Just press OK.
Now there's something you need to do for the compilation to succeed:
open Configuration Manager
choose Release Build
untick Build for De.TorstenMandelkow.MetroChart
Building
right-click De.TorstenMandelkow.MetroChart.WPF project and build it
when built, find the DLL in MetroChart\De.TorstenMandelkow.MetroChart.WPF\bin\Release
Reference the project
create a new WPF project
add a reference to De.TorstenMandelkow.MetroChart.dll
XAML :
<Window x:Class="WpfApplication3.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:metroChart="clr-namespace:De.TorstenMandelkow.MetroChart;assembly=De.TorstenMandelkow.MetroChart"
xmlns:wpfApplication3="clr-namespace:WpfApplication3"
Title="MainWindow"
Width="525"
Height="350">
<Window.Resources>
<wpfApplication3:MyObjectCollection x:Key="MyObjectCollection">
<wpfApplication3:MyObject Category="Category1" Value="100" />
<wpfApplication3:MyObject Category="Category2" Value="200" />
<wpfApplication3:MyObject Category="Category3" Value="300" />
</wpfApplication3:MyObjectCollection>
<metroChart:ResourceDictionaryCollection x:Key="CustomColors">
<ResourceDictionary>
<SolidColorBrush x:Key="Brush1" Color="#FF5B9BD5" />
</ResourceDictionary>
<ResourceDictionary>
<SolidColorBrush x:Key="Brush2" Color="#FFED7D31" />
</ResourceDictionary>
<ResourceDictionary>
<SolidColorBrush x:Key="Brush3" Color="#FFA5A5A5" />
</ResourceDictionary>
<ResourceDictionary>
<SolidColorBrush x:Key="Brush4" Color="#FFFFC000" />
</ResourceDictionary>
<!-- add more values with a different key -->
</metroChart:ResourceDictionaryCollection>
</Window.Resources>
<Grid>
<metroChart:PieChart Palette="{StaticResource CustomColors}"
>
<metroChart:PieChart.Series>
<metroChart:ChartSeries DisplayMember="Category"
ItemsSource="{StaticResource MyObjectCollection}"
ValueMember="Value" />
</metroChart:PieChart.Series>
</metroChart:PieChart>
</Grid>
</Window>
Code-behind:
using System.Collections.ObjectModel;
using System.Windows;
namespace WpfApplication3
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow() {
InitializeComponent();
}
}
internal class MyObject
{
public string Category { get; set; }
public int Value { get; set; }
}
internal class MyObjectCollection : ObservableCollection<MyObject>
{
}
}
Result
See https://modernuicharts.codeplex.com/documentation for help.
Related
So a few things to establish before I get into the meat of things:
I'm using .NET 4.0 without having the option to upgrade
I'm limited to VS2010 for my IDE
My application uses the MVVM pattern
It involves a launcher application as a gateway to the underlying apps, which is the intended end-user UX flow
The code is split between multiple projects within the same solution
When I launch the problematic application as standalone, it works perfectly fine; It has issues when I launch it from the launcher application though
The launcher launches the application in a separate window, as a separate process
In essence what the underlying app is meant for is generating and filling out reports with different types of clauses to be checked off (Text, numeric, alphanumeric) and have different data fields, due to which there are a handful of templates for the data to be displayed appropriately in the View.
The issue is when my application is putting together the View to show the generated report, it fails to find the Template Picker.
My base project contains reusable user controls and ViewModels that are reused in the report generation apps. This is where the UserControl for the ListBox for each item in the report's list of items is located. This is also where the C# class for the TemplatePicker is located.
My Condition Report project contains the views for the report-builder application, as well as the styles used across this report-builder. It has it's Models and ViewModels stored in separate projects respectively. This is where the XAML definition for the TemplatePicker is located.
This is the code for the CustomListBox where it references my TemplatePicker.
<xmlns:ConditionsPicker="clr-namespace:eSOCs.Base.Helpers;assembly=eSOCs.Base"/>
<ListBox SelectedValue="{Binding Path=DataContext.SelectedCondition}"
Grid.Row="5" Grid.RowSpan="3" Grid.ColumnSpan="9"
Visibility="{Binding Path=DataContext.ConditionsListBoxVisibility, Converter={StaticResource BooleanToVisibilityConverter}}"
ItemsSource="{Binding Path=DataContext.ConditionsForGroup}"
ItemTemplateSelector="{StaticResource ResourceKey=ConditionTemplatePicker}" Margin="1,6,-1,117"
x:Name="ListBoxConditions">
This is the code excerpt from my DataTemplates.xaml which is the xaml definition for my TemplatePicker (ConditionsListTemplatePicker is the c# class for the template picker):
<xmlns:ConditionsPicker="clr-namespace:eSOCs.Base.Helpers;assembly=eSOCs.Base"/>
<ConditionsPicker:ConditionsListTemplatePicker x:Key="ConditionTemplatePicker"
DefaultConditionTemplate="{StaticResource DefualtCondiditonTemplate}"
TextMessageConditionTemplate="{StaticResource TextCondiditonTemplate}"
PolymerConditionTemplate="{StaticResource PolymerSourceTemplate}"
RecoveryConditionTemplate="{StaticResource PolymerSourceTemplate}"
TextConditionTemplate="{StaticResource ConditionTextDataTemplate}"/>
And this is my App.xaml for the report-builder app adding to the ResourceDictionary:
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="/Styles/Colors.xaml" />
<ResourceDictionary Source="/Styles/Fonts.xaml" />
<ResourceDictionary Source="/Styles/Strings.xaml" />
<ResourceDictionary Source="/Styles/Controls.xaml" />
<ResourceDictionary Source="/Styles/Labels.xaml" />
<ResourceDictionary Source="/Styles/Canvas.xaml" />
<ResourceDictionary Source="/Styles/TextBlock.xaml" />
<ResourceDictionary Source="/Styles/Borders.xaml" />
<ResourceDictionary Source="/Styles/ListBox.xaml" />
<ResourceDictionary Source="/Styles/Buttons.xaml" />
<ResourceDictionary Source="/Styles/Windows.xaml" />
<ResourceDictionary Source="/Styles/ComboBox.xaml" />
<ResourceDictionary Source="/Styles/ProgressBar.xaml" />
<ResourceDictionary Source="/Styles/CustomKeypadStyle.xaml" />
<ResourceDictionary Source="/CustomSelectionPopup/CustomPopupTextBoxStyle.xaml" />
<ResourceDictionary Source="/Styles/DataTemplates.xaml" />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
This is the code that performs the process-creation from within the context of the launcher:
public void BringExeToForeground(string exeLocation, string processName)
{
try
{
Process window = null;
if (!string.IsNullOrEmpty(BaseLine.StandardConditionsConnectionString) && !string.IsNullOrEmpty(BaseLine.EsocsConnectionString) && !string.IsNullOrEmpty(BaseLine.ElogConnectionString))
{
var process = GetProcess(processName);
if (process == null)
{
ProcessStartInfo startArgs = new ProcessStartInfo();
startArgs.FileName = exeLocation;
startArgs.Arguments = BaseLine.LineNumber + " " + BaseLine.DeviceVersion + " " + BaseLine.ApplicationVersion;
Process.Start(startArgs);
}
else
{
BringProcessToFront(process);
}
}
else if (!CheckIfProcessIsAlreadyRunning(processName))
{
window = Process.Start(exeLocation);
}
}
catch (Exception ex)
{
LogSystem.LogSystem.LogMessage(LogSystem.LogSystemMessageTypes.Exception, ex.Message, ex.GetType().ToString(), ex.GetType().Name);
}
}
Despite all of this, I have an exception thrown at runtime because CustomListBox cannot resolve the TemplatePicker resource.
Any help is greatly appreciated!
I have a flyout in my app that I use to add additional contacts into the local database. This flyout is declared as a page resource currently, and does exactly what I need it to, however in order to re-use it on a different page I need to copy both the xaml for the flyout and any attatched events to each page that would require using it (there are several places where a contact might need to be added)
Is there a way to globally define a flyout such that I only need to reference it rather than hardcode it each time? I considered using a ContentDialog (as that can be defined as its own module) but I don't think that would be the right fit
If creating completely in code is not an option you can create a ResourceDictionary with a class in background. First the Styles.xaml:
<ResourceDictionary
x:Class="MyClass.Styles"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Flyout x:Key="MyFlyout">
<!-- my flyout code -->
</Flyout>
</ResourceDictionary>
The important thing here is x:Class, where the value needs to be the namespace+name of the related class we're creating now (Styles.cs in that case):
namespace MyClass {
public partial class Styles {
public Styles() {
this.InitializeComponent();
}
// my events from flyout
}
}
Make sure that the class is declared as partial and calls this.InitializeComponent() in the constructor.
Now in your app resources add a reference:
<Application
...
xmlns:myClass="using:MyClass">
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<myClass:Styles />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
</Application>
Then you can access the Flyout as a static resource, e.g.:
<Button Flyout="{StaticResource MyFlyout}" />
I am currently testing AvalonDock. I want to create the layout via MVVM.
I have the problem, that databound titles for anchorables (not for documents) are shown in the designer but missing when running the program.
I found this example and recreated a much simpler version to reproduce the problem.
Here is what I did:
Created a blank solution with a WPF application inside
Added Xceed WPF Toolkit v3.0 via Nuget
Created this very simple viewmodel:
namespace NonWorkingAvalonDock {
public sealed class MainViewModel {
public MainViewModel() {
Pages = new SimplePageViewModel[] {
new SimplePageViewModel("Foo"),
new SimplePageViewModel("Bar")
};
}
public SimplePageViewModel[] Pages { get; }
}
public sealed class SimplePageViewModel {
public SimplePageViewModel(string title) {
Title = title;
}
public string Title { get; }
}
}
Made my XAML to look like this:
<Window x:Class="NonWorkingAvalonDock.MainWindow"
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:NonWorkingAvalonDock"
xmlns:dock="http://schemas.xceed.com/wpf/xaml/avalondock"
xmlns:dockctrl="clr-namespace:Xceed.Wpf.AvalonDock.Controls;assembly=Xceed.Wpf.AvalonDock"
mc:Ignorable="d"
Title="MainWindow" Height="350" Width="525">
<Window.Resources>
<local:MainViewModel x:Key="ViewModel" />
</Window.Resources>
<dock:DockingManager DataContext="{StaticResource ViewModel}" AnchorablesSource="{Binding Pages}" >
<dock:DockingManager.LayoutItemContainerStyle>
<!-- you can add additional bindings from the layoutitem to the DockWindowViewModel -->
<Style TargetType="{x:Type dockctrl:LayoutItem}" >
<Setter Property="Title" Value="{Binding Model.Title}" />
</Style>
</dock:DockingManager.LayoutItemContainerStyle>
</dock:DockingManager>
</Window>
Now, in Expression blend this looks correct:
But when I run my application, I get this:
I think I am missing something, but I can't figure out what, since the example from github runs perfectly.
Followup:
I investigated the example and my code a bit more, and in the example, the author sets the data context in code behind. When I do this, it works for me, too.
Moreover, I did the following experiment: I made the Pages property privately writable, initialized it with null and used a Timer which sets the view models after one second. When I do this, I get the titles, too.
Ok, I busting my head on this for few hours now and still cannot find a solution.
first I shall explain the simple test case I created:
Solution
- ClassLibrary1
- Dictionary1.xaml
- WpfApplication3
- App.config
- App.xaml
- Dictionary2.xaml
- MainWindows.xaml
ClassLibrary1:
That project has the required references to allow me to add wpf-dictionary:
PresentationCore, PresentationFramework, Systam.Xaml, windowsbase
(Along with all standard assemblies for any regular class library)
And this is Dictionary1.xaml:
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Color x:Key="PrimaryBackgroundColor">#FF030010</Color>
<SolidColorBrush x:Key="PrimaryBackgroundBrush" Color="{StaticResource PrimaryBackgroundColor}" />
</ResourceDictionary>
WpfApplication3:
This project just display a button on a wpf-form.
Dictionary2.xaml:
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:WpfApplication3">
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="pack://application:,,,/ClassLibrary1.dll;component/Dictionary1.xaml"/>
</ResourceDictionary.MergedDictionaries>
<Style TargetType="Button">
<Setter Property="Background" Value="{StaticResource PrimaryBackgroundBrush}" />
</Style>
</ResourceDictionary>
MainWindow.xaml:
<Window x:Class="WpfApplication3.MainWindow"
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:WpfApplication3"
mc:Ignorable="d"
Title="MainWindow" Height="350" Width="525">
<Window.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Dictionary2.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Window.Resources>
<Grid>
<Button Content="aaa" Width="100" Height="40" />
</Grid>
</Window>
That's all - very simple as you can see.
The only thing here is that dictionary2 need to use resource from dictionary1.
And so there are two ways to reference another assembly:
Option 1:
The class-library is a project in your solution and your WpfApplication adds reference to the class library project which is in the same solution. this is done via Add-Reference/Projects, And in that situation all works great.
Option 2:
The class-library is not your solution. (actually it can be like in my example)
however you add reference by adding reference to ClassLibrary1.Dll which resides either in your
bin\debug or bin\release folders.
In that situation a portal to hell is opened.
Dictionary2 complains it cannot find the resource 'PrimaryBackgroungBrush' and upon execution it crush
complaining it cannot find the dictionary1.xaml
Exception thrown: 'System.Windows.Markup.XamlParseException' in PresentationFramework.dll
and the inner exception:
{"Could not load file or assembly 'ClassLibrary1.dll, Culture=neutral' or one of its dependencies.
The system cannot find the file specified.":"ClassLibrary1.dll, Culture=neutral"}
The problem is that using option2 is essential as I want to share the same dictionary among other wpf projects without
having the ClassLibrary1 project as part of their solution.
Suggested way to reproduce:
Create a new solution in Visual studio for WPF application.
Add class library project to the solution.
In class libarary project, Add references to the following assemblies: PresentationCore, PresentationFramework, Systam.Xaml, windowsbase
Add Wpf-Dictionary 'Dictionary1' to your class library project and copy the code. (you can copy one from the wpf project since it will not exist as an option in the add item from the class library)
Add Wpf-Dictionary 'Dictionary2' to your wpf application and copy the code.
Copy the code for MainWindow.
And now:
Add reference to class library (as project, from projects tab in add refernce dialog)
Build everything - all should work.
Remove the refernce to class library.
Add reference to class library (as dll, from browse tab and find it in your classlibrary/bin/debug or release folder)
Build everything - you will notice my problem.
Any solution to this problem?
UPDATE 1
I changed the line in dictionary2.xaml from:
<ResourceDictionary Source="pack://application:,,,/ClassLibrary1.dll;component/Dictionary1.xaml"/>
To:
<ResourceDictionary Source="pack://application:,,,/ClassLibrary1;component/Dictionary1.xaml"/>
And now the project compiles and execute without an error, However while in design time - the xaml view of dictionary2 indicate that it cannot find the resource: 'PrimaryBackgroundBrush` and puts the ugly curly underline below it.
So its a progress - but i'm still not happy with that.
Any ideas how to solve that?
UPDATE 2
As previously stated - everything compiles and execute now.
However what you see in the following picture annoys me,
I just want to be sure that others who added the class library as .Dll file and not as project 100% sure they don't get that problem which can be seen in the picture, meaning their xaml intellisense can recognize the resource during design time.
I could imagine how documentation about that dll will looks like:
reference dll in the project
add this to resource dictionary in the project:
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="pack://application:,,,/ClassLibrary1.dll;component/Dictionary1.xaml"/>
</ResourceDictionary.MergedDictionaries>
add this to each window/usercontrol:
<Window.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Dictionary2.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Window.Resources>
Which looks afwul.
How about making manager in your library which has to be referenced by each window/usercontrol and it will do things automatically?
Here is a cut from theme manager I mentioned in comments (it does merging automatically), think about easy of use.
xaml (add this to each window/usercontrol which has to support theme switching in design/run time):
local:Theme.Theme=""
cs (this part has to be a part of library):
public static class Theme
{
public static readonly DependencyProperty ThemeProperty =
DependencyProperty.RegisterAttached("Theme", typeof(string), typeof(Theme), new PropertyMetadata(null, (d, e) =>
{
var theme = (string)e.NewValue;
// in run-time set theme to specified during init
if (!DesignerProperties.GetIsInDesignMode(d))
theme = _theme;
var element = d as FrameworkElement;
element.Resources.MergedDictionaries.Clear();
if (!string.IsNullOrEmpty(theme))
{
var uri = new Uri($"/MyPorject;component/Themes/{theme}.xaml", UriKind.Relative);
element.Resources.MergedDictionaries.Add(new ResourceDictionary() { Source = uri });
}
}));
public static string GetTheme(DependencyObject obj) => (string)obj.GetValue(ThemeProperty);
public static void SetTheme(DependencyObject obj, string value) => obj.SetValue(ThemeProperty, value);
static string _theme = "Generic";
static string[] _themes = new[]
{
"Test",
};
/// <summary>
/// Init themes
/// </summary>
/// <param name="theme">Theme to use</param>
public static void Init(string theme)
{
if (_themes.Contains(theme))
_theme = theme;
}
}
P.S.: functionality is primitive (it is sufficient in my case), but should give you an idea.
I am starting working with MVVMCross.
I had created the View and view model.
The View.xaml look like that:
<views:MvxWindowsPage
x:Class="xxx.Client.UWP.Views.View1"
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:views="using:Cirrious.MvvmCross.WindowsUWP.Views"
mc:Ignorable="d">
But I get this error:
The name "MvxWindowsPage" does not exist in the namespace "using:Cirrious.MvvmCross.WindowsUWP.Views"
But in my View.xaml.cs i had inherited from it without error:
public sealed partial class View1 : Cirrious.MvvmCross.WindowsUWP.Views.MvxWindowsPage
Do you know what the problem is?
Thanks.
I tested it with MvvmCross 4.0.0-beta3, and it works without any problem.
If you are using the correct version, see if you can repro the issue using the following steps. Just want to make sure we are doing the same thing.
In Visual Studio 2015 RTM-> new-> project-> c#-> windows-> universal-> Blank App(Universal Windows) name it "Test.Client.UWP".
Right click on the project node in VS solution explorer -> Manage NuGet Packages -> Check "include prerelease" and search mvvmcross -> Select the Latest prerelease 4.0.0-beta3 and install. (make sure there is no error in output window)
Add Views folder in the project root -> Add a blank page named View1 -> do the following changes:
Change to View1.xaml.cs
namespace Test.Client.UWP.Views
{
/// <summary>
/// An empty page that can be used on its own or navigated to within a Frame.
/// </summary>
public sealed partial class View1 : Cirrious.MvvmCross.WindowsUWP.Views.MvxWindowsPage
{
public View1()
{
this.InitializeComponent();
}
}
}
Change to View1.xaml
<views:MvxWindowsPage
xmlns:views="using:Cirrious.MvvmCross.WindowsUWP.Views"
x:Class="Test.Client.UWP.Views.View1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:Test.Client.UWP.Views"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d">
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
</Grid>
</views:MvxWindowsPage>