Search the Community

Showing results for tags 'visualization'.

More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


    • Announcements
  • GraphX for .NET (open-source)
    • Updates & Releases
    • Discussions
    • Documents & Tutorials
    • Bug reports
    • Redirect to GraphX repository on GitHub
  • General Discussions
    • General software discussions
    • Monogame/XNA
  • International Discussions
    • Обсуждения на русском
  • News & Announcements
  • Discussions

Found 14 results

  1. Now also on Twitter: Latest source code with specified changes is available on GitHub Version 2.3.8 WIP DETAILED CHANGELOG: - Implemented multiple labels logic for edges. Now you can display multiple labels across the edge - Added LabelHorizontalOffset property for labels which offsets labels along the edge given some offset value in total edge length percent CODE CHANGES: - Properties ShowLabel,LabelVerticalOffset,AlignLabelsToEdges moved from EdgeControlBase to EdgeLabelControl class - Property AlignLabelsToEdges renamed to AlignToEdge - Property EdgeControlBase.EdgeLabelControl renamed to EdgeLabelControls and now has IList<IEdgeLabelControl> type - Added new method IList<SysRect> EdgeControlBase.GetLabelSizes() - Added new method IList<IEdgeLabelControl> EdgeControlBase.GetLabelControls() - GraphArea.ShowAllEdgesLabels() method now has one-time effect and will not be reapplied after relayout - GraphArea.ShowAllEdgesLabels() method now has one-time effect and will not be reapplied after relayout - GraphArea.EdgeLabelFactory is now setup up with default factory generating one AttachableEdgeLabelControl - Label factory method CreateLabel() now returns IEnumerable<TResult> to accomodate multiple labels generation during single factory pass OBSOLETE AND REMOVED STUFF: General - Old style arrows are now not supported - Old style edge labels (EdgeLabelControl) are now not supported, make sure to remove it from XAML templates and update your code to use AttachableEdgeLabelControl EdgeControlBase - LabelAngle - GetLabelSize() - SetCustomLabelSize() EdgeControl - LabelMouseDown event removed Other: - showLabel parameter has been removed from all EdgeControl constructors and factories
  2. RELEASE 2.3.6 DETAILED CHANGELOG: + Added edge endpoint calculation for rotated vertex that use ellipse, circle and rectangle math shape + Added VertexControl::LabelAttached and LabelDetached events which fires when new label is attached to VertexControl or detached from it + Added new parameter to GraphArea::UpdateParallelEdgesData(Dictionary<TEdge, EdgeControl> edgeList) to be able to specify edges list to parse for parallelization instead of full edge list parse + Added support for object visbility and attachable labels to GraphX serialization data + Added ZoomControl::ResetKeyBindings() method to clear all (incl default) set key bindings + Fixed ZoomControl dynamic content switch to corectly refresh viewfinder + Improved ZoomControl handling with disabled animation + Renamed ZoomControl::IsAnimationDisabled to IsAnimationEnabled and changed the logic according the modification + Renamed ZoomControl::MaximumZoomStep to ZoomStep and updated description + Implemented easy ZoomControl key bindings with BindKey() method and exposed base commands for zoom and pan actions to be able to bind keys for them + Some class refactoring Go to the archive & sources download page NuGet version is also available
  3. Greetings everyone! Today we proudly announce the release of the GraphX for .NET PRO 1.0.0 version which is planned as our mainstream product! We have a great plans for it so you may expect more features and content to be added soon followed by special highlights. Feel free to read through this announce and ask us questions if you'll have some. So, what's inside? GraphX PRO utilizes open-source GraphX logic core making possible for you to use all the algorithms from this version and all the possible custom algorithms you already have. This also allows us to create new PRO algorithms compatible with open-source GraphX which is still a great visualization tool for templated interactive graphs. Using the PRO version you gain access to a set of new high performance controls designed to handle large data graphs in WPF and UWA environments by utilizing the low-level rendering techniques. These controls allows you to build your graph visualization from scratch skipping the heavy XAML templates and optimize overall performance by using fast and efficient graph object techniques. We also have an performance-tweaked zoom control and additional layout algorithms to play with. For example this highly customizable Radial Layout Algorithm can do the magic with the tree data graphs. Here are some GraphX PRO highlights we have to offer you: New controls for maximum rendering performance you can achieve in WPF. New low-level rendering techniques and plenty of performance optimizations allowed us to create controls better suitable for large data graph rendering and visualization. Also we have more performant ZoomControl to offer. New layout algorithms for better tree graph visualization with different configurable options, including Radial Tree Layout. Expect more algorithms to come soon. Extended support for both FREE and PRO GraphX products including the access to VIP customers area on the forums and guaranteed quick responses on all the questions related to GraphX and derived projects. Priority version updates and feature requests. Access to requested hotfixes in any desirable form and ability to request minor new features with top priority mark. More tools to work with will be added in the future including new algorithms, controls and much more. Special discounts and offers for other services including GraphX-based paid project development and feature implementation! On-demand source code access that includes full GraphX PRO source code sharing and support The Requirements? We want to supply our customers with the best software possible so we have to use modern tools to achieve the best performance and usability . GraphX for .NET PRO software requirements as follows: Visual Studio 2015 Community Edition or higher (for sample projects) .NET Framework 4.5* or higher * Compatibility with other framework versions is a subject for a discussion, feel free to contact us What about the license? GraphX for .NET PRO utilize subscription based licensing model which means you can get new product versions while your license is active and continue to use them even when your license is expired. You won't be able to use new product releases after your license is expired and you have to renew it to be able to do so. Each license is valid for one developer only but if you want to purchase GraphX PRO for many developers you can always contact with the Sales Department. Check the subscription details on our new web-sites: Have Something Special? Sure! We want to thank all our contributors and give them life-time -15% discount for indie and professional bundles if you'd contributed to GraphX before the PRO version release. We appreciate your work and hope to see you working with us on the free open-source GraphX version. Remember, buying our products also helps to push forward our open-source projects! For all the questions regarding the GraphX PRO please contact or use the order form below ** The text given above is not a public offer
  4. There has been some new data filtering features introduced In GraphX version 2.3.5. Let's see the quick review. In order to provide more flexible data filtering for GraphX the LogicCore::Filters property has been introduced representing the Queue<IGraphFilter<TVertex, TEdge, TGraph>> of custom filters. The queue means that the filters that are added into it are processed in a FIFO (First In First Out) order consequently modifying the graph. Filters are automaticaly applied on GraphArea::GenerateGraph() and GraphArea::RelayoutGraph() method calls before any visuals are calculated and ensures that all calculations will be done on filtered graph. In case of relayout, each relayout method call will initiate filtering process starting from "original graph". Original graph is the copy of the LogicCore::Graph property that is saved before first filter is applied on an unfiltered graph to have an untouched graph copy. Also we'd implemented dynamic visuals add/remove routine specially for the filters in the relayout process so during the each relayout method call GraphX will now check if there are vertices or edges that needs VertexControl/EdgeControl objects to be created/removed to reflect changes made by filters. This behavior can be turned off by setting GraphArea::EnableVisualsRenewOnFiltering property to False. You can check if graph is currently filtered by checking the LogicCore::IsFiltered property. Furthermore you have several methods to work with data filtering: LogicCore::PushFilters() - this method is called automaticaly as described above and applies LogicCore::Filters to LogicCore::Graph. You can also call it manually to push the filtering for your custom purpose. LogicCore::ApplyFilters() - this method will remove graph filtering, clear all filters, clear original graph and save filtered graph as unfiltered making the changes permanent. You want to make changes from filtering permanent? That is the method! LogicCore::PopFIlters() - this method will remove graph filtering, clear all filters, clear original graph and revert LogicCore::Graph property to original graph saved earlier. Want to revert all the filtering changes and restore the graph? You can do it! PS: Remember that while you operate with filtered graph you hold the original graph copy in the memory which can cause performance issues depending on the graph size. The graph data filter itself is very simple: public class BlueVertexFilter: IGraphFilter<DataVertex, DataEdge, BidirectionalGraph<DataVertex, DataEdge>> { public BidirectionalGraph<DataVertex, DataEdge> ProcessFilter(BidirectionalGraph<DataVertex, DataEdge> inputGraph) { inputGraph.RemoveVertexIf(a => !a.IsBlue); return inputGraph; } } It has only one method named ProcessFilter() that do all the stuff. This method receive some graph as the input parameter and shoud return the graph when it is done with the filtering. So, basically you will want to do the following: Create custom filters derived from IGraphFilter interface Add them to LogicCore::FIlters in desired order Run GraphArea::GenerateGraph() or GraphArea::RelayoutGraph() methods That's it! If you need this feature functionality expanded please let me know, thanks!
  5. RELEASE 2.3.0 WIP Highlights: Added new layout algorithm GroupingLayoutAlgorithm which allows to layout graph vertices by different groups each using its own sublayout algorithm. You can see it in action using new feature highlight in showcase app. Currently there are two modes supported: Layout groups to predefined bounds, when you can specify rectangular bounds in which vertices are layed out (Bounds must be supported by algorithm used to layout vertices group) Generate bounds from groups, when each group is layouted using its algorithm and bounds are automatically calculated to fit all vertices in the group and then group bounds overlaps can be removed. Added two new label controls AttachedEdgeLabelControl and AttachedVertexLabelControl which acts like separate entities in GraphArea visual tree and have weak references to graphx controls. Default EdgeLableControl and VertexLabelControl are designed to act as the part of their parent classes and this approach impacts their customization possibilities when these parent classes are limited in size. So with the new labels you can mitigate following restrictions: No more label cuts when vertex is strictly limited in width or height No more jerky edge endpoints when edge label is too large No more labels behind edges or vertices. You can control how to inject them. To use new labels you have to add AttachedVertexLabel and/or AttachedEdgeLabel XAML templates and also set GraphArea::VertexLabelFactory / EdgeLabelFactory. Detailed changelog: Added GroupId property to IGraphXVertex interface Added parameters class RandomLayoutAlgorithmParams for corresponding algorithm. It contains Bounds property which can restrict vertex coordinates to respect provided bounds. Added two methods to EdgeControl: GetEdgePointerForSource() and GetEdgePointerForTarget() which allows to get to edge pointer objects manually Added VertexShape.Ellipse math shape Added support for reversing the geometry. This is required for animating shapes along a path where the direction needs to be reversed without using the Storyboard.AutoReverse property (thanks to bleibold) Added two new attached label classes for Edge and Vertex controls. Added EdgeControl::LabelMouseDown event Added separate ID counter for edges while autoresolving missing id Added EdgeControl::UpdateLabel() method to be able to update attached edge label manually (tech means to overcome some template puzzles) Added GraphArea::GetChildControls() method to easily fetch any child objects (incl. custom) by condition or just get all of them Fixed id autoresolve issue when calling GraphArea::GenerateAllEdges() after manual edge data compilation (thanks to Hannes Hasenauer) Fixed some METRO code that hasn't been ported correctly Fixed an exception in ZoomControl caused by Ctrl + Alt + DblClick combination (thanks to persalmi) Fixed NaN result for FR algorithms calc (thanks to bleibold) Fixed edge bundling in the case when empty Control points are present that would sometimes cause exceptions.(thanks to bleibold) Fixed numerous event issues with GraphX controls where events wasn't passed down the hierarchy tree Fixed edge label size on some template manipulations by adding additional update on label size change event. You can turn it off using EdgeLabelControl::UpdateLabelOnSizeChange property. Fixed bindings to DefaultEdgePointer::Visibility property Improved styles flexibility by working with dependency values instead of straight assignment in some places Improved random layout algorithm randomness by seeding new Guid hash which fixes some odd behavior in rare cases Improved overall graph cleaning in different areas allowing to easily clean graph data and fix potential memory leaks Implemented edge cut logic for EdgePointer placed at edge 'source' to gain better visual quality like its 'target' counterpart Implemented many changed in algorithm base classes, mainly in AlgorithmLayoutBase: made VisitedGraph and VertexPositions props assignable externally Implemented RandomLayoutAlgorithms to derive from LayoutAlgorithmBase class Merged GraphArea code for WPF & METRO into a shared files Merged EdgeControl and VertexControl code for WPF & METRO into the shared files Breaking changes: IExternalLayoutAlgorithm interface now demands TEdge generic specification and have one new method ResetGraph(). All built-in algorithms now use IMutableVertexAndEdgeSet<TVertex, TEdge> for TGraph generic specification to be able to modify Graph data on demand. Made Vertex and Edge ID Int64 be default. Was Int32. Added mandatory IOverlapRemovalAlgorithm::Initialize() method for all OR algorithms to be able to initialize initial data not only when you instantiate class but at any time Go to the archive & sources download page NuGet version is also available
  6. RELEASE 2.2.0 RELEASE NOTES: New features can still have some bugs as there are many scenarios that might involve them and it's hard to check all of them on my own. If you feel uncomfortable with anything in this release please let me know. I appreciate any feedback as this is almost the only reason i'm still working on GraphX. Thanks! NEW TERMS: VAESPS - vertex and edge skip processing support VCP - vertex connection point HIGHLIGHTS: VCPs has been added into GraphX making edge endpoint fixation(binding) possible. By default GraphX automaticaly calculates edge endpoint position relative to vertex dimensions and approximate math shape, but with this feature on you'll be able to bind edge endpoint to a separate customizable object. This will allow you to create static edge fixation endpoints on the vertex and give you full control over edge endpoints positioning. Now GraphX for WPF requires only .NET Framework 4.0 to build & run. Deprecated all code that required .NET 4.0.3 Now you can easily customize edge pointers with the help of DefaultEdgePointer class which can host any content including Image/Path and supports rotation. Changes include more precious edge endpoint calculations so the edge will overlap with the edge pointer no more. Because of these changes the old logic that utilizes direct Path object in EdgeControl template will be removed completely in favor of notable performance improvements. Serialization has been decoupled from GraphX completely to allow bring much more freedom to custom serializers. All what GraphX do now is provide serialization data and accept serialization data for deserialization. Serialization classes are not limited by interfaces now. See FileServiceProviderWpf class for an example. Now you can use "" XAML namespace in GraphX for WPF for all its visual content. Additionaly, assemblies (and output filenames) for WPF/METRO dlls are both changed to GraphX.Controls.dll so Post-Build process copies output files to GraphX/Bin folder with distinct filenames reflecting the platform as before. Performance improvements are always welcome. In this release the whole layout calculation logic has been revisited in terms of both performance and code quality gains. We've also eliminated some redundant layout updates, moved all math & algorithms handling from GraphArea directly to LogicCore under better async implementation, cleaned up ZoomControl logic, revisited edges & edge labels code to remove redundant calculation passes. DETAILED CHANGES: Added support for custom VCP [WPF, METRO] * New control class added: StaticVertexConnectionPoint. It represents ContentControl which can host virtualy any valid object. * VCP supports the same math shapes as VertexShape property or can use VertexShape::None value to disable precise edge endpoint calculations Added vertex and edge skip processing support to METRO version (VAESPS) [METRO] Added VAESPS for following algorithms: Circular [ALL] Added VertexShape::None enum option, currently affecting only VCP logic [ALL] Added different layout options to EfficientSugiyama algorithm using new Direction param [ALL] Added true orthogonal edge routing for EfficientSugiyama algorithm using EdgeRouting param [ALL] Added new property GraphArea::ControlsDrawOrder which defines vertex or edges should be drawn topmost [WPF, METRO] Added GraphArea::PreloadGraph() method for manual graph rendering which generate vertices and edges from GraphArea::LogicCore.Graph property w/o any algorithms and also sets vertices positions if needed [WPF, METRO] Added new EdgeControl template PART (PART_SelfLoopedEdge) for custom self looped edge indicator visualization. It represents FrameworkElement and if specified in the template will be positioned in the top left vertex corner. Also made indicator settings more flexible by implementing some dependency props [WPF, METRO] Added StateStorage::SaveOrUpdateState() method for easier use [WPF,METRO] Added new read only property EdgeControl::IsParallel that identifies edge as currently parallel to other edge. Made GraphArea::UpdateParallelEdgesData() method public to be able to refresh IsParallel property on manual graph operations [METRO, WPF] Added EdgeLabelControl::FlipOnRotation dependency property which controls if label should be flipped when axis is changed while rotating [WPF, METRO] Fixed parallel edges labels handling. Now edge labels are more readable when there are two of them [WPF, METRO] Fixed edge routing when graph state has been loaded. Graph state now stores AlgorithmStorage too [ALL] Fixed ZoomControl zoom-out to the value equal to zoom-in resulting in similar smooth zoom [WPF, METRO] Fixed ZoomControl::Zoom property change not firing [WPF, METRO] Fixed manual graph composition routines in case of ER algorithm is set [ALL] Fixed layout algorithm calculations to always receive actual vertex positions as input parameter. This will fix VAESPS for default algorithms. [WPF, METRO] Fixed outdated edge rendering in some cases when vertex coordinates are changed manually [WPF, METRO] Fixed edge overlapping edge pointers [WPF, METRO] Fixed use of ControlFactory for edge deserialization [WPF, METRO] thanks to perturbare Fixed some algorithm calculation problems, especial FR [ALL] Fixed EdgeControl.ShowArrows to implement DependencyProperty [WPF, METRO] thanks to perturbare Fixed minor performance problems in ZoomControl [METRO] Fixed and enhanced automatic data object Id resolve logic [WPF,METRO] thanks to perturbare Fixed ZoomControl zoom sometimes not firing from code call after control is loaded [WPF] Fixed VB sample project dependencies and refactored code a bit Reorganized Example apps namespaces and code for greater good Made EdgeControlBase::UpdateEdge() method public. It can be used now to fully update edge visual on custom edge-related modifications [WPF, METRO] Improved main layout calculation logic to gain performance improvements [WPF, METRO] Merged EdgePointerImage and EdgePointerPath into one universal DefaultEdgePointer class [WPF, METRO] Improved edge and its template parts rendering/calc performance [WPF, METRO] Enhanced edge labels logic so now it don't require additional template bindings and modifications (Angle or RenderTransform) [WPF] GraphArea::PreloadVertexes() now accepts graph param as optional (null by default) and uses LogicCore.Graph in that case [WPF, METRO] Decoupled serialization logic from GraphX completely [ALL] thanks to perturbare Adjusted FR and BoundedFR default values for random initial positions [All] Now GraphX for WPF requires only .NET Framework 4.0 to build & run [WPF] Refactored almost all of the GraphX code for improvements and code quality. Changed many namespaces for better name reflection [ALL] BREAKING CHANGES: !!!WARNING!!! This GraphX version has fallen under the heavy hand of code refactoring and along with the numerous code improvements almost ALL of the namespaces has been changed to better reflect logical code grouping and ease additional platform support through code reusability. Also i've get rid of the several different XAML xmlns usings in favor of single one. I'm very sorry that this changes will force you to update your GraphX projects but i realy felt that i must do it once and for all. You will have to change most of the usings in code and XAML templates: i strongly recommend you to use Resharper or any other code quality tool which will help you to do this in minutes (or even seconds). Core changes: - All controls, behaviours and their interfaces are moved to GraphX.Controls namespace - All algorithms are spreaded across GraphX.PCL.Logic.Algorithms namespace with additional OverlapRemoval, LayoutAlgorithms, EdgeRouting endings - All base models and interfaces are now in GraphX.PCL.Common.Models namespace - All GraphX primitives (Point, Rect, etc.) are left in GraphX.Measure for better code readability in cases when they are intersected with System.Windows namespace twins IGXLogicCore now include ExternalLayoutAlgorithm, ExternalOverlapRemovalAlgorithm, ExternalEdgeRoutingAlgorithm properties for simplier external algo assignment Now GraphX for WPF requires only .NET Framework 4.0 to build & run Serialization decoupling process changes some method names: GraphArea::SerializeToFile() -> GraphArea::ExtractSerializationData() and GraphArea:: DeserializeFromFile() -> GraphArea::RebuildFromSerializationData() EdgeLabelControl no longer needs default Angle binding and RenderTransformOrigin setup. They are processed internally [WPF] GraphArea::GenerateGraph() method now has generateAllEdges param True by default. Renamed following peoperties, moved them to EdgeControlBase and implemented them as DependencyProperty: - LogicCore::EdgeSelfLoopCircleOffset -> SelfLoopIndicatorOffset - LogicCore::EdgeSelfLoopCircleRadius -> SelfLoopIndicatorRadius - LogicCore::EdgeShowSelfLooped -> ShowSelfLoopIndicator Renamed following ZoomControl properties: - ZoomDeltaMultiplier -> ZoomSensitivity - MaxZoomDelta -> MaximumZoomStep Completely deprecated EdgeControl::PART_edgeArrowPath template PART in favor of the new DefaultEdgePointer (PART_EdgePointerForSource & PART_EdgePointerForTarget). Please renew your custom templates. You can find an example in Generic.XAML template. Self looped edges display logic has been slightly changed with the introduction of custom template PART (PART_SelfLoopedEdge). Now LogicCore::EdgeSelfLoopElementOffset is (0,0) by default and indicator is shown in the top left vertex corner minus indicator size. You can change this behavior by overriding EdgeControl::PrepareEdgePath() method. GetVertexSizeRectangles() method moved from GraphArea to LogicCore. Edge labels placement logic has been slightly changed when they are applied to parallel edges. Labels offset now translates them into different directions, for ex. one up, one down, one up.. etc. This behavior helps to better place labels for double parallels. Also parallel edge labels now are not flipped when axis changes during label rotation. If you're uncomfortable with these changes, please let me know!
  7. There was old nuget GraphX version hanging around about an year or so. I've completely forgot about it, but thanks to some users, my attention has been redirected into right direction! Now the library has been reuploaded and includes GraphX v2.1.7 for .NET4.0+ and Win8.1 Store (METRO). Feel free to use and test it.
  8. METRO support has been introduced with the latest source upload into PCL branch. This is still beta so don't expect stable release anytime soon. Feel free to test it and leave some feedback. Basicaly, two new projects has been added: GraphX.METRO.Controls - core library Examples/METRO.SimpleGraph - example project There are some functionality limitations compared to WPF GraphX version that hopefuly will be reimplemented in future releases. Currently there are some issues that has not yet be resolved (including edge labels handling).
  9. I've made some research in PCL a while ago and now i've come to the need to port GraphX to PCL-compliant format to be able to use it with a wider range of Microsoft platforms. The task itself is quite complicated so i felt the need to share the info on the progress and porting results with the community. You can find new PCL BRANCH in GitHub repository (can be broken from time to time as it is WIP branch). Currently the following specifications are supported/required for the PCL version (logic and common libs only): Min requirement and support: .NET framework v4.0.3 (not common enough but supported in WinXP, needed for enchanced PCL features such as LINQ support) Min support: Siverlight 4 and above Min support: Windows Phone 8 Min support: Windows Metro 8 As you may already be familiar with the PCL concept it is clear that we need to do the following: Globaly convert GraphX to PCL compliant format (preserving all current features) so i have to maintain only one library version Convert GraphX.Common and GraphX.Logic to PCL Implement GraphX.Controls library for each platform individualy (first of all Windows Desktop version has to be reworked) For the moment i've successfuly finished most of the work (hopefuly without the major breaking changes) and currently i'm looking for an additional library optimization and feature isolations. So far the following solutions has been implemented: Implemented custom Semaphore class to use in EdgeBundling technique Implemented custom IClonable interface for some classes that use cloning Moved latest YAXlib project into the solution and splitted it into PCL and non-PCL projects to be able to use field attributes and custom serializers in PCL libraries Implemented custom classes from System.Windows namespace: Point, Rect, Size, Vector Removed Debug calls Removed HighResolutionTime class from PathFinder edge routing as it used DLL injection and unsafe code Implemented workaround for some PCL non-compliant code such as LINQ extensions *Moved MathHelper class to Controls library as it is primarily used for visuals and doing this helps to avoid excessive type conversions Implemented IGraphControl.SetPosition(double x, double y) method to avoid some type conversions Solved file operations problem by introducing IFileServiceProvider interface and corresponding property in GXLogicCore class. The implementation of this interface is platform specific so it must be implemented for each platform separately. Good news is that when you assign LogicCore property of the GraphArea the new default (platform-specific) FileServiceProvider is created and assigned to LogicCore automaticaly. This approach helps to avoid breaking changes so you can use general file operation methods as you've used them before. Additionaly this approach allows you to easily implement custom type serialization (or use 3rd party serialization libraries). Discussion of current problems and approaches: I've decided to implement my own System.Windows types (as default ones are not supported in PCL) that are used throughout the libraries and this decision leads me to a massive rework of GraphX.Controls library. I have to implement type conversions wisely to avoid heavy impact on the performance (custom type <-> original System.Windows type). That is the most important problem for now that has to be solved correctly, so that is why it would be nice to hear some opinions on the matter. Currently i see two possible ways to solve it: a) Completely rework library to eliminate that types usage in PCL Implement type conversions before-set/after-get values in visuals ops YAXLib serialization is currently located in GXCore and has to be moved somewhere in platform dependent library as it uses reflection which is unsupported in PCL. Do we realy need Silverlight 4 support? I'm no pro in SL so i can't tell it for sure. If we target Silverlight 5 as minimum requirement we can get the following platforms supported: a) Windows Phone 8.1 Xamarin Android c) Xamarin iOS That is all i've got now. Hope to see some feedback. Thanks!
  10. Finally! GraphX repository has been moved to GitHub: Now you can easily submit your code improvements and contribute to the project! GitHub also allows to fork GraphX sources into your own repository copy to work with it independently.
  11. Along with the bug fixes this version brings some new functionality. For example, GraphArea now can restore (reapply) visual properties (that was previously set using GraphArea methods such as GraphArea::SetVerticesDrag()) for VertexControl and EdgeControl objects. You can also switch this off for better performance or manual handling. Also some new methods and properties has been added to simplify work with GraphX, read the change log for details. Change log: + Added GraphArea::AddCustomChildControl() and GraphArea::RemoveCustomChildControl() methods to make the possibility to add any custom controls that are not vertex or edge. + Added ZoomControl::ToContentRectangle() method which translates screen rectangle coordinates to content rectangle coordinates + Added correct endpoints rendering for parallel edges on a rectangular vertex shape (thanks ro bleibold) + Added some hooks for ZoomControl to notify Presenter::RenderTransform on scale/translation changes. Now bindings to that property are correctly refreshed. + Added additional handling of custom objects in GraphArea (eg. clearing) + Added dependency property for GraphArea::LogicCore + Added new property GraphArea::EnableVisualPropsRecovery. Gets or sets if visual properties such as edge dash style or vertex shape should be automaticaly reapplied to visuals when graph is regenerated. Turning this off can save a bit of performance if you don't use custom values. + Added new property GraphArea::EnableVisualPropsApply. Gets or sets if visual properties such as edge dash style or vertex shape should be automaticaly applied to newly added visuals which are added using AddVertex() or AddEdge() or similar methods. Turning this off can save a bit of performance if you don't use custom values and making many manual edge/vertex create or remove operations. + Added GraphArea::SetVerticesHighlight() and GraphArea::SetEdgesHighlight() methods for easier highlight feature handling. + Improved some showcase code + Improved GraphArea code performance (slightly) + Fixed minimap rectangle drag issue + Fixed issue with ZoomControl area selection by Ctrl+Alt+Click + Fixed issue with GraphArea::VertexSelected event + Fixed issue with inproper overlap removal work (that issue affected some algorithms vis) using new coordinates system. + Fixed issue with incorrect rendering of parallel edges (thanks to bleibold) - GraphArea::Children property has been hidden. Use EdgesList and VertexList properties and corresponding methods instead. VISIT DOWNLOADS PAGE
  12. Finally GraphX v2 has made it to the public and is now in the process of active polishing. New project architecture easily allows to perform porting GraphX to different platforms as visualization has been separated from logic. Also the logics module can now be use independently of GraphX to calculate graph layouts and edge routings for custom projects. Currently there are no officialy released ports but there is work in progress for Silverlight and Windows 8 solutions. There are no estimate dates for port releases as there is no exact information will it also be an open-source projects or projects on the paid basis. Most notable features for this version are: Portable architecture support. Still testing, but all of the core features except file handling and serialization has been made PCL compliant. Separated algorithms in standalone GXLogicCore class. Now you can easily use all GraphX algorithms separately from visual stuff. ZoomControl enchanced. Merged most viable features of ZoomControl and Zoombox into one control and made smooth graph representation while dragging vertices. Parallel edges support and rotated edge labels. Further enchanced edge visualization by implementing parallel edges visualization between the same vertices and labels that are aligned to the edges by angle. Thanks to all of you who support GraphX on the road to perfection! This adventure would not be so exciting without you
  13. Finally GraphX v2 has made it to the public. Though it don't have much new features it definetly bring new capabilities and architectural improvements. Starting from this product version it is now possible to move forward the porting solutions with ease. Currently there are no officialy released ports but there is work in progress for Silverlight and Windows 8 solutions. Most notable features for this version are: Portable architecture support. Still testing, but all of the core features except file handling and serialization has been made PCL compliant. Separated algorithms in standalone GXLogicCore class. Now you can easily use all GraphX algorithms separately from visual stuff. ZoomControl enchanced. Merged most viable features of ZoomControl and Zoombox into one control and made smooth graph representation while dragging vertices. Parallel edges support and rotated edge labels. Further enchanced edge visualization by implementing parallel edges vis between same vertices and labels aligned to the edge by angle. There are some key moments that you must be aware of that can break old v1 projects. They are: GraphArea now uses coordinates system that place objects by TOP-LEFT corner. Old system operated by object CENTER coordinates. So you need to check your logic to be sure that you operate with coorect coordinates. GraphArea canvas object real size now always (10, 10) so if used separately from ZoomControl it must be centered in container. No matter what its children are placed relatively so the whole picture looks the same. Zoombox has been removed. Use enchanced ZoomControl instead. If you lack any features, please let me know. Also currently it is not possible to use ZoomControl for hosting objects other than GraphArea out of the box. If you need it for other purposes ypou have to modify its interaction logic with GraphArea. All logic has been moved from GraphArea to GXLogicCore. You need to modify calls to methods and properties in your code, please look at the examples provided in source code. Source code and documentation updates will follow soon. Changelog: + Spearated GraphX into the 3 projects: GraphX.Common, GraphX.Logic and GraphX.Controls. Each project serves its own purpose. GraphX.Logic contains all the logic and algorithms GraphX.Common contains common objects between logic and visual controls GraphX.Controls contains visual controls and all associated classes + Added GraphArea.LogicCore property that must be set in order to be able to work with GraphArea + Added parallel edges logic call in GraphArea.UpdateAllEdges() method + Added some code improvements and corrections, made some classes internal, abstract or sealed + Added EdgeControl::AlignLabelsToEdges and EdgeControl::LabelVerticalOffset properties that implements edge labels alignment to edges at different angles. Labels now can be placed at the same angle as edge is drawn and optionaly offseted up or down to not overlap the edge itself. + Added some recently implemented features to Showcase app + Added optional param to GraphArea::GenerateAllEdges() that enables GraphArea layout update before edges calculation. True by default. + Added minimap from Zoombox to ZoomControl and changed some of its features. + Added new method ZoomControl::ZoomToContent() that should be used instead of ZoomTo() method + Added ZoomControl display in VS design view with minimap preview + Slightly improved rendering performance for large graphs + Fixed long living issue with zoom content resize and vertex drag which involves following global changes: + Correct GraphArea size rectangle can now be only determined by GraphArea::ContentSize property whcih contains rectangle that includes all viusuals added. GraphArea visual size remains ALWAYS intact at (10,10). + Now all vertices and edges positioned in GraphArea using TOP-LEFT corner as the position coordinates (previously coordinates was pointing at the object center). + ZoomControl now closely tied with GraphX, though it can be made universal + Fixed edge labels rendering issue + Fixed some showcase app exceptions + Fixed edge labeling showcase example + Fixed GraphArea in design diplay mode + Fixed ParameterizedLayoutAlgorithm exception (thanks to thinkJD) + Fixed parallel edges calculations in case of opposite-directed edges (thanks to thinkJD) + Fixed invalid parallel edges detection in some cases (thanks to bleibold) - Image export currently supports only ZoomControl visible area export - Moved ImageType enum into GraphX namespace - Moved all properties associated with logic from GraphArea to GXLogicCore class - Removed Zoombox from project completely (now only ZoomControl is supported and being actively enchanced) VISIT DOWNLOADS PAGE
  14. Yes, i've decided to name it GraphX v2 at the moment From the current milestone i see following features that makes difference: Separate libraries design - all algorithms and logic are in the standalone library that can be used separately from GraphX. PCL version - portable compact libraries can be hot-referenced in Windows (Framework 4.0), Silverlight 5, WindowsPhone 8 and Windows 8 applications. Silverlight platform support There is no alpha at the moment but if you are interested, you can contribute by following matters: PM me if you have any cool zoom control library for Silverlight. It is real pain to transfer ZoomBox to silverlight PM me if you're interested in Silverlight XAML animation and visualization development. Well, some SL limitations is a pain for me