private UIElement initEmptyGraphVisualization()
{
_zoomControl = new ZoomControl();
ZoomControl.SetViewFinderVisibility(_zoomControl, Visibility.Visible);
var logic = new GXLogicCore <NodeV, EdgeV, BidirectionalGraph <NodeV, EdgeV> >();
_graphAreaVisualizer = new GraphAreaVisualizer {
LogicCore = logic,
EdgeLabelFactory = new DefaultEdgelabelFactory()
};
logic.DefaultLayoutAlgorithm = LayoutAlgorithmTypeEnum.LinLog;
logic.DefaultLayoutAlgorithmParams = logic.AlgorithmFactory.CreateLayoutParameters(LayoutAlgorithmTypeEnum.LinLog);
//((LinLogLayoutParameters)logic.DefaultLayoutAlgorithmParams). = 100;
logic.DefaultOverlapRemovalAlgorithm = OverlapRemovalAlgorithmTypeEnum.FSA;
logic.DefaultOverlapRemovalAlgorithmParams = logic.AlgorithmFactory.CreateOverlapRemovalParameters(OverlapRemovalAlgorithmTypeEnum.FSA);
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).HorizontalGap = 50;
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).VerticalGap = 50;
logic.DefaultEdgeRoutingAlgorithm = EdgeRoutingAlgorithmTypeEnum.None;
logic.AsyncAlgorithmCompute = false;
_graphAreaVisualizer.ShowAllEdgesLabels(true);
_zoomControl.Content = _graphAreaVisualizer;
var myResourceDictionary = new ResourceDictionary {
Source = new Uri("Templates\\template.xaml", UriKind.Relative)
};
_zoomControl.Resources.MergedDictionaries.Add(myResourceDictionary);
return(_zoomControl);
}
private void DendrogramLayout_OnIsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
{
if (DendrogramLayout.IsVisible)
{
ZoomControl.ZoomToFill();
}
}
public async override Task OnNavigatedTo(object param)
{
IsInitialized = false;
Time = string.Empty;
ranges = new List<SlowMoRange>();
Recording = false;
video = null;
//Init capture
DeviceInformation device = await DeviceHelper.GetCameraDeviceInfoAsync(Panel.Back);
MediaCaptureInitializationSettings captureInitialization = InitCaptureSettings(device);
await InitMediaCapture(captureInitialization);
Zoom = MediaCapture.VideoDeviceController.ZoomControl;
RaisePropertyChanged(() => MediaCapture);
//Start preview
await SetHightestAvailableVideoResolutionPreview();
await mediaCapture.StartPreviewAsync();
(App.Current as App).IsPreviewing = true;
IsHelpOn = settings.IsFirstLaunch;
IsInitialized = true;
settings.IsFirstLaunch = false;
}
// TODO : Remove all hide/show extensions from here.
void drag_Started(DragListener drag)
{
var designPanel = ExtendedItem.Services.DesignPanel as DesignPanel;
if (designPanel != null)
{
var p = VisualTreeHelper.GetParent(designPanel);
while (p != null && !(p is ZoomControl))
{
p = VisualTreeHelper.GetParent(p);
}
zoom = p as ZoomControl;
}
/* Abort editing Text if it was editing, because it interferes with the undo stack. */
foreach (var extension in this.ExtendedItem.Extensions)
{
if (extension is InPlaceEditorExtension)
{
((InPlaceEditorExtension)extension).AbortEdit();
}
}
oldSize = new Size(ModelTools.GetWidth(ExtendedItem.View), ModelTools.GetHeight(ExtendedItem.View));
if (resizeBehavior != null)
{
operation = PlacementOperation.Start(extendedItemArray, PlacementType.Resize);
}
else
{
changeGroup = this.ExtendedItem.Context.OpenGroup("Resize", extendedItemArray);
}
_isResizing = true;
ShowSizeAndHideHandles();
}
private UIElement GenerateElementVisuals()
{
_zoomControl = new ZoomControl();
ZoomControl.SetViewFinderVisibility(_zoomControl, Visibility.Visible);
GXLogicCore <Node, BeltPlanGraphEdge, BeltPlanGraphCore> logicCore = new GXLogicCore <Node, BeltPlanGraphEdge, BeltPlanGraphCore>();
_graph = new BeltPlanGraph
{
LogicCore = logicCore,
EdgeLabelFactory = new DefaultEdgelabelFactory(),
};
_graph.ShowAllEdgesLabels(false);
logicCore.Graph = GenerateGraphCore();
logicCore.DefaultLayoutAlgorithm = _layoutAlgorithm;
logicCore.DefaultLayoutAlgorithmParams = logicCore.AlgorithmFactory.CreateLayoutParameters(_layoutAlgorithm);
logicCore.DefaultOverlapRemovalAlgorithm = _overlapAlgorithm;
logicCore.DefaultOverlapRemovalAlgorithmParams = logicCore.AlgorithmFactory.CreateOverlapRemovalParameters(_overlapAlgorithm);
logicCore.DefaultOverlapRemovalAlgorithmParams.HorizontalGap = 50;
logicCore.DefaultOverlapRemovalAlgorithmParams.VerticalGap = 50;
logicCore.DefaultEdgeRoutingAlgorithm = _edgeAlgorithm;
logicCore.DefaultEdgeRoutingAlgorithmParams = logicCore.AlgorithmFactory.CreateEdgeRoutingParameters(_edgeAlgorithm);
logicCore.AsyncAlgorithmCompute = false;
_zoomControl.Content = _graph;
return(_zoomControl);
}
public NNGraph()
{
InitializeComponent();
_editorManager = new EditorObjectManager(graphArea, zoomCtrl);
var dgLogic = new LogicCoreExample();
graphArea.LogicCore = dgLogic;
graphArea.VertexSelected += graphArea_VertexSelected;
graphArea.EdgeSelected += graphArea_EdgeSelected;
graphArea.SetVerticesMathShape(VertexShape.Circle);
dgLogic.DefaultLayoutAlgorithm = LayoutAlgorithmTypeEnum.Custom;
dgLogic.DefaultOverlapRemovalAlgorithm = OverlapRemovalAlgorithmTypeEnum.None;
dgLogic.DefaultEdgeRoutingAlgorithm = EdgeRoutingAlgorithmTypeEnum.None;
dgLogic.EdgeCurvingEnabled = true;
zoomCtrl.IsAnimationEnabled = false;
ZoomControl.SetViewFinderVisibility(zoomCtrl, Visibility.Visible);
zoomCtrl.Zoom = 2;
zoomCtrl.MinZoom = .5;
zoomCtrl.MaxZoom = 50;
zoomCtrl.ZoomSensitivity = 25;
zoomCtrl.MouseDown += zoomCtrl_MouseDown;
butDelete.Checked += ToolbarButton_Checked;
butSelect.Checked += ToolbarButton_Checked;
butEdit.Checked += ToolbarButton_Checked;
butSelect.IsChecked = true;
}
/// <summary>
/// Gets the underlying <see cref="PointedTreeGraph"/> from the <paramref name="control"/>.
/// </summary>
/// <param name="control">The control to get the underlying <see cref="PointedTreeGraph"/>.</param>
/// <returns>The found <see cref="PointedTreeGraph"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="control"/> is <c>null</c>.</exception>
public static PointedTreeGraph GetPointedTreeGraph(PointedTreeGraphControl control)
{
ZoomControl zoomControl = GetZoomControl(control);
var graphLayout = (PointedTreeGraphLayout)zoomControl.Content;
return(graphLayout.Graph);
}
UIElement RedrawGraph(ref BiGraphArea <string> _gArea)
{
_zoomctrl = new ZoomControl();
ZoomControl.SetViewFinderVisibility(_zoomctrl, Visibility.Visible);
var logic = new GXLogicCore <Node <string>, Base.Edge <string>, BidirectionalGraph <Node <string>, Base.Edge <string> > >();
_gArea = new BiGraphArea <string>
{
// EnableWinFormsHostingMode = false,
LogicCore = logic,
EdgeLabelFactory = new DefaultEdgelabelFactory()
};
_gArea.ShowAllEdgesLabels(true);
logic.Graph = current_graph;
logic.DefaultLayoutAlgorithm = ((LayoutAlgorithmTypeEnum)(layoutcombo.SelectedItem as ComboBoxItem).Tag);
logic.DefaultLayoutAlgorithmParams = logic.AlgorithmFactory.CreateLayoutParameters(((LayoutAlgorithmTypeEnum)(layoutcombo.SelectedItem as ComboBoxItem).Tag));
//((LinLogLayoutParameters)logic.DefaultLayoutAlgorithmParams). = 100;
logic.DefaultOverlapRemovalAlgorithm = OverlapRemovalAlgorithmTypeEnum.FSA;
logic.DefaultOverlapRemovalAlgorithmParams = logic.AlgorithmFactory.CreateOverlapRemovalParameters(OverlapRemovalAlgorithmTypeEnum.FSA);
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).HorizontalGap = 50;
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).VerticalGap = 50;
logic.DefaultEdgeRoutingAlgorithm = ((EdgeRoutingAlgorithmTypeEnum)(ercombo.SelectedItem as ComboBoxItem).Tag);
logic.EnableParallelEdges = paredge.Checked;
logic.ParallelEdgeDistance = edgedist.Value;
logic.AsyncAlgorithmCompute = false;
_zoomctrl.Content = _gArea;
_gArea.RelayoutFinished += gArea_RelayoutFinished;
var myResourceDictionary = new ResourceDictionary {
Source = new Uri("WpfTemplate\\template.xaml", UriKind.Relative)
};
_zoomctrl.Resources.MergedDictionaries.Add(myResourceDictionary);
return(_zoomctrl);
}
/// <summary>
///
/// </summary>
private void Register()
{
//
graph_area_ = AssociatedObject;
// Find the graph behavior
graphBehavior = Interaction.GetBehaviors(graph_area_).OfType <NodeGraphBehavior>().FirstOrDefault();
if (graphBehavior != null)
{
graphBehavior.VerticesCollectionChanged += GraphBehavior_VerticesCollectionChanged;
graphBehavior.EdgesCollectionChanged += GraphBehavior_EdgesCollectionChanged;
}
// Travel up the visual tree and get the zoom control
// If the zoom control doesn't exist, then we can't use this behavior
// TODO: Done on logical tree for now because visual tree is not valid during behavior OnAttachAndLoaded()
zoom_control_ = graph_area_.FindLogicalParentOfType <ZoomControl>();
if (zoom_control_ == null)
{
// TODO throw exception!
}
graph_area_.VertexSelected += OnVertexSelected;
graph_area_.VertexMouseUp += OnVertexMouseLeftButtonUp;
graph_area_.EdgeSelected += OnEdgeSelected;
zoom_control_.AreaSelected += OnVertexAreaSelected;
zoom_control_.MouseLeftButtonUp += OnMouseLeftButtonUp;
zoom_control_.MouseLeftButtonDown += OnMouseLeftButtonDown;
selected_vertices_.CollectionChanged += OnSelectedVerticesChanged;
selected_edges_.CollectionChanged += OnSelectedEdgesChanged;
}
private UIElement GenerateWpfVisuals()
{
_zoomctrl = new ZoomControl();
ZoomControl.SetViewFinderVisibility(_zoomctrl, Visibility.Visible);
var logic = new GXLogicCore <DataVertex, DataEdge, BidirectionalGraph <DataVertex, DataEdge> >();
_gArea = new GraphAreaExample
{
// EnableWinFormsHostingMode = false,
LogicCore = logic,
EdgeLabelFactory = new DefaultEdgelabelFactory()
};
_gArea.ShowAllEdgesLabels(true);
logic.Graph = GenerateGraph();
logic.DefaultLayoutAlgorithm = LayoutAlgorithmTypeEnum.LinLog;
logic.DefaultLayoutAlgorithmParams = logic.AlgorithmFactory.CreateLayoutParameters(LayoutAlgorithmTypeEnum.LinLog);
//((LinLogLayoutParameters)logic.DefaultLayoutAlgorithmParams). = 100;
logic.DefaultOverlapRemovalAlgorithm = OverlapRemovalAlgorithmTypeEnum.FSA;
logic.DefaultOverlapRemovalAlgorithmParams = logic.AlgorithmFactory.CreateOverlapRemovalParameters(OverlapRemovalAlgorithmTypeEnum.FSA);
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).HorizontalGap = 50;
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).VerticalGap = 50;
logic.DefaultEdgeRoutingAlgorithm = EdgeRoutingAlgorithmTypeEnum.None;
logic.AsyncAlgorithmCompute = false;
_zoomctrl.Content = _gArea;
_gArea.RelayoutFinished += gArea_RelayoutFinished;
var myResourceDictionary = new ResourceDictionary {
Source = new Uri("Templates\\template.xaml", UriKind.Relative)
};
_zoomctrl.Resources.MergedDictionaries.Add(myResourceDictionary);
return(_zoomctrl);
}
public MyGraphArea() : base()
{
this.graph = new MyGraph();
this.zoomControl = null;
this.model = null;
this.activeObjects = new Dictionary <Type, bool>()
{
{ typeof(MyAsset), true },
{ typeof(MyConcept), true },
{ typeof(MyEnum), true },
{ typeof(MyEvent), true },
{ typeof(MyParticipant), true },
{ typeof(MyTransaction), true }
};
this.activeReferences = true;
this.activeAbstractions = true;
this.LogicCore = new MyLogicCore(this);
this.CommandAsset = new DelegateCommand <bool?>(this.CommandObject <MyAsset>);
this.CommandConcept = new DelegateCommand <bool?>(this.CommandObject <MyConcept>);
this.CommandEnum = new DelegateCommand <bool?>(this.CommandObject <MyEnum>);
this.CommandEvent = new DelegateCommand <bool?>(this.CommandObject <MyEvent>);
this.CommandParticipant = new DelegateCommand <bool?>(this.CommandObject <MyParticipant>);
this.CommandTransaction = new DelegateCommand <bool?>(this.CommandObject <MyTransaction>);
this.CommandReference = new DelegateCommand <bool?>(this.CommandReferences);
this.CommandAbstraction = new DelegateCommand <bool?>(this.CommandAbstractions);
this.SetVerticesDrag(true, true);
}
public MainWindow()
{
InitializeComponent();
ZoomControl.SetViewFinderVisibility(zoomctrl, Visibility.Visible);
zoomctrl.ZoomToFill();
}
public virtual void GenerateButtonClick(object sender, System.EventArgs e)
{
this.NGramListBox.Enabled = true;
var dataVertex = new DataVertex();
if (this.serachTextBox.Text != string.Empty)
{
NGram <T> s = this.CreateNGRamFromSearchTextBox();
if (s != NGram <T> .Empty)
{
this.CurrentMarkovGraph = this.MarkovGraph.GetSubGraphFromNGram(s, this.Depth);
if (this.MarkovGraph.ValidNode(s))
{
this.wpfContainer.Child = this.GenerateWpfVisuals(GraphUIHelper.GenerateGraphUI(this.CurrentMarkovGraph));
}
}
}
GraphArea.GenerateGraph(true);
GraphArea.SetVerticesDrag(true, true);
ZoomControl.ZoomToFill();
this.UpdateListBox();
}
public UIElement GenerateWpfVisuals(GraphExample example)
{
ZoomControl = new ZoomControl();
ZoomControl.SetViewFinderVisibility(ZoomControl, System.Windows.Visibility.Visible);
/* ENABLES WINFORMS HOSTING MODE --- >*/
var logic = new GXLogicCore <DataVertex, DataEdge, BidirectionalGraph <DataVertex, DataEdge> >();
GraphArea = new GraphAreaExample()
{
EnableWinFormsHostingMode = true, LogicCore = logic
};
logic.Graph = example;
logic.DefaultLayoutAlgorithm = GraphX.LayoutAlgorithmTypeEnum.KK;
logic.DefaultLayoutAlgorithmParams = logic.AlgorithmFactory.CreateLayoutParameters(GraphX.LayoutAlgorithmTypeEnum.KK);
((KKLayoutParameters)logic.DefaultLayoutAlgorithmParams).MaxIterations = 100;
logic.DefaultOverlapRemovalAlgorithm = GraphX.OverlapRemovalAlgorithmTypeEnum.FSA;
logic.DefaultOverlapRemovalAlgorithmParams = logic.AlgorithmFactory.CreateOverlapRemovalParameters(GraphX.OverlapRemovalAlgorithmTypeEnum.FSA);
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).HorizontalGap = 50;
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).VerticalGap = 50;
logic.DefaultEdgeRoutingAlgorithm = GraphX.EdgeRoutingAlgorithmTypeEnum.None;
logic.AsyncAlgorithmCompute = false;
ZoomControl.Content = GraphArea;
GraphArea.RelayoutFinished += GAreaRelayoutFinished;
var myResourceDictionary = new ResourceDictionary {
Source = new Uri("Templates\\template.xaml", UriKind.Relative)
};
ZoomControl.Resources.MergedDictionaries.Add(myResourceDictionary);
return(ZoomControl);
}
public GraphView()
{
InitializeComponent();
mainWindow = App.Current.MainWindow as MainWindow;
dataGraph = new TestFeederGenerator.Models.GraphX();
mainWindow.graphView = this;
ZoomControl.SetViewFinderVisibility(zoomctrl, Visibility.Visible);
zoomctrl.ZoomToFill();
last_added_id = 1;
//setup Area properties
GraphAreaExample_Setup();
//setup graph properties
startGraphDrawing();
undo.IsEnabled = false;
redo.IsEnabled = false;
(mainWindow.graphView.DataContext as GraphViewModel).undoRedoCommander = new UndoRedoCommander(this.DataContext);
}
void ApplySetting(ZoomControl zoom, GraphArea area, bool nav = false)
{
//Zoombox.SetViewFinderVisibility(zoom, System.Windows.Visibility.Visible);
//This property sets vertex overlap removal algorithm.
//Such algorithms help to arrange vertices in the layout so no one overlaps each other.
area.DefaultOverlapRemovalAlgorithm = GraphX.OverlapRemovalAlgorithmTypeEnum.FSA;
area.DefaultOverlapRemovalAlgorithmParams = Area.AlgorithmFactory.CreateOverlapRemovalParameters
(GraphX.OverlapRemovalAlgorithmTypeEnum.FSA);
if (nav)
{
((OverlapRemovalParameters)area.DefaultOverlapRemovalAlgorithmParams).HorizontalGap = 150;
((OverlapRemovalParameters)area.DefaultOverlapRemovalAlgorithmParams).VerticalGap = 100;
}
else
{
((OverlapRemovalParameters)area.DefaultOverlapRemovalAlgorithmParams).HorizontalGap = 50;
((OverlapRemovalParameters)area.DefaultOverlapRemovalAlgorithmParams).VerticalGap = 50;
}
//This property sets edge routing algorithm that is used to build route paths according to algorithm logic.
//For ex., SimpleER algorithm will try to set edge paths around vertices so no edge will intersect any vertex.
//Bundling algorithm will try to tie different edges that follows same direction to a single channel making complex graphs more appealing.
area.DefaultEdgeRoutingAlgorithm = GraphX.EdgeRoutingAlgorithmTypeEnum.None;
//This property sets async algorithms computation so methods like: Area.RelayoutGraph() and Area.GenerateGraph()
//will run async with the UI thread. Completion of the specified methods can be catched by corresponding events:
//Area.RelayoutFinished and Area.GenerateGraphFinished.
area.AsyncAlgorithmCompute = true;
//area.UseLayoutRounding = false;
area.UseNativeObjectArrange = false;
}
private void MasterRefresh()
{
GetRandomizerData();
if (graph != null)
{
graph.Dispose();
}
graph = Grapher.CreateTransitionGraph();
if (zoom == null)
{
zoom = new ZoomControl();
ZoomControl.SetViewFinderVisibility(zoom, Visibility.Visible);
elementHost1.Child = zoom;
}
zoom.Content = graph;
zoom.Zoom = 0.01f;
zoomToVertexSelect.Items.Clear();
zoomToVertexSelect.Items.AddRange(roomRandomizer ? rooms.ToArray() : areas.ToArray());
graph.GenerateGraph(true);
Grapher.RecolorVertices(graph);
edgeLabelsToggled = false;
zoom.ZoomToFill();
}
// Zoom control - Increase, Decrease, Reset
private void Tsmi_ZoomControlManager_Click(object sender, EventArgs e)
{
ToolStripMenuItem clickedItem = (ToolStripMenuItem)sender;
switch (clickedItem.Text)
{
case "Restore Default Zoom":
{
rt_CodeEditor.ZoomFactor = ZoomControl.SetZoom(ZoomState.Default, rt_CodeEditor.ZoomFactor,
ZoomControl.ZoomStep);
break;
}
case "Zoom Increase":
{
rt_CodeEditor.ZoomFactor = ZoomControl.SetZoom(ZoomState.Increase, rt_CodeEditor.ZoomFactor,
ZoomControl.ZoomStep);
break;
}
case "Zoom Decrease":
{
rt_CodeEditor.ZoomFactor = ZoomControl.SetZoom(ZoomState.Decrease, rt_CodeEditor.ZoomFactor,
ZoomControl.ZoomStep);
break;
}
}
Sddb_zoom.Text = ZoomControl.GetZoomString(rt_CodeEditor.ZoomFactor);
}
private UIElement GenerateWpfVisuals()
{
zoomctrl = new ZoomControl();
ZoomControl.SetViewFinderVisibility(zoomctrl, System.Windows.Visibility.Visible);
/* ENABLES WINFORMS HOSTING MODE --- >*/
var logic = new GXLogicCore <DataVertex, DataEdge, BidirectionalGraph <DataVertex, DataEdge> >();
gArea = new GraphAreaExample()
{
EnableWinFormsHostingMode = true, LogicCore = logic
};
logic.Graph = GenerateGraph();
logic.DefaultLayoutAlgorithm = GraphX.LayoutAlgorithmTypeEnum.KK;
logic.DefaultLayoutAlgorithmParams = logic.AlgorithmFactory.CreateLayoutParameters(GraphX.LayoutAlgorithmTypeEnum.KK);
((KKLayoutParameters)logic.DefaultLayoutAlgorithmParams).MaxIterations = 100;
logic.DefaultOverlapRemovalAlgorithm = GraphX.OverlapRemovalAlgorithmTypeEnum.FSA;
logic.DefaultOverlapRemovalAlgorithmParams = logic.AlgorithmFactory.CreateOverlapRemovalParameters(GraphX.OverlapRemovalAlgorithmTypeEnum.FSA);
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).HorizontalGap = 50;
((OverlapRemovalParameters)logic.DefaultOverlapRemovalAlgorithmParams).VerticalGap = 50;
logic.DefaultEdgeRoutingAlgorithm = GraphX.EdgeRoutingAlgorithmTypeEnum.None;
logic.AsyncAlgorithmCompute = false;
zoomctrl.Content = gArea;
gArea.RelayoutFinished += gArea_RelayoutFinished;
return(zoomctrl);
}
public void Constructor_ExpectedValues()
{
// Call
using (var graphControl = new PointedTreeGraphControl())
{
// Assert
Assert.IsInstanceOf <UserControl>(graphControl);
Assert.IsInstanceOf <IPointedTreeGraphControl>(graphControl);
Assert.IsNull(graphControl.Data);
Assert.IsNull(graphControl.Selection);
Assert.AreEqual(1, graphControl.Controls.Count);
ZoomControl zoomControl = PointedTreeGraphControlHelper.GetZoomControl(graphControl);
Assert.AreEqual(300, zoomControl.ZoomDeltaMultiplier);
Assert.AreEqual(ZoomControlModes.Original, zoomControl.Mode);
Assert.AreEqual(ZoomViewModifierMode.None, zoomControl.ModifierMode);
Assert.AreEqual(new TimeSpan(0), zoomControl.AnimationLength);
Assert.AreEqual(1, zoomControl.Resources.MergedDictionaries.Count);
ResourceDictionary templateDictionary = zoomControl.Resources.MergedDictionaries.First();
Assert.AreEqual("/Core.Components.GraphSharp.Forms;component/Templates/PointedTreeGraphTemplate.xaml", templateDictionary.Source.AbsolutePath);
var graphLayout = (PointedTreeGraphLayout)zoomControl.Content;
Assert.IsInstanceOf <PointedTreeGraph>(graphLayout.Graph);
}
}
// TODO : Remove all hide/show extensions from here.
protected virtual void drag_Started(DragListener drag)
{
ArrowLine al = ExtendedItem.View as ArrowLine;
CurrentX2 = al.X2;
CurrentY2 = al.Y2;
CurrentLeft = (double)al.GetValue(Canvas.LeftProperty);
CurrentTop = (double)al.GetValue(Canvas.TopProperty);
var designPanel = ExtendedItem.Services.DesignPanel as DesignPanel;
zoom = designPanel.TryFindParent <ZoomControl>();
if (resizeBehavior != null)
{
operation = PlacementOperation.Start(extendedItemArray, PlacementType.Resize);
}
else
{
changeGroup = this.ExtendedItem.Context.OpenGroup("Resize", extendedItemArray);
}
_isResizing = true;
(drag.Target as DesignerThumb).IsPrimarySelection = false;
}
private void GeneralGraph_Constructor()
{
var gg_Logic = new LogicCoreExample();
gg_Area.LogicCore = gg_Logic;
//gg_Area.DefaulOverlapRemovalAlgorithm
gg_layalgo.ItemsSource = Enum.GetValues(typeof(LayoutAlgorithmTypeEnum)).Cast <LayoutAlgorithmTypeEnum>();
gg_layalgo.SelectedIndex = 0;
gg_oralgo.ItemsSource = Enum.GetValues(typeof(OverlapRemovalAlgorithmTypeEnum)).Cast <OverlapRemovalAlgorithmTypeEnum>();
gg_oralgo.SelectedIndex = 0;
gg_eralgo.ItemsSource = Enum.GetValues(typeof(EdgeRoutingAlgorithmTypeEnum)).Cast <EdgeRoutingAlgorithmTypeEnum>();
gg_eralgo.SelectedIndex = 2;
gg_but_randomgraph.Click += gg_but_randomgraph_Click;
gg_vertexCount.Text = "30";
gg_async.Checked += gg_async_Checked;
gg_async.Unchecked += gg_async_Checked;
gg_Area.RelayoutFinished += gg_Area_RelayoutFinished;
gg_Area.GenerateGraphFinished += gg_Area_GenerateGraphFinished;
gg_Logic.DefaultEdgeRoutingAlgorithm = EdgeRoutingAlgorithmTypeEnum.None;
ZoomControl.SetViewFinderVisibility(gg_zoomctrl, System.Windows.Visibility.Visible);
gg_zoomctrl.IsAnimationDisabled = false;
gg_zoomctrl.MaxZoomDelta = 2;
this.Loaded += GG_Loaded;
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
ZoomControl.SetViewFinderVisibility(ZoomCtrl, Visibility.Visible);
ZoomCtrl.ZoomToFill();
LayoutAlgorithmComboBox.ItemsSource = GetLayoutAlgorithmName();
LayoutAlgorithmComboBox.SelectedIndex = 0;
}
private void UpdateGraph()
{
this.wpfContainer.Child = GenerateWpfVisuals(GraphUIHelper.GenerateGraphUI <T>(this.CurrentMarkovGraph));
GraphArea.GenerateGraph(true);
GraphArea.SetVerticesDrag(true, true);
ZoomControl.ZoomToFill();
}
private void UpdateGraph(NGramGraphMarkovChain <T> chain)
{
this.wpfContainer.Child = GenerateWpfVisuals(GraphUIHelper.GenerateGraphUI <T>(chain));
GraphArea.GenerateGraph(true);
GraphArea.SetVerticesDrag(true, true);
ZoomControl.ZoomToFill();
}
void Area_RelayoutFinished(object sender, EventArgs e, ZoomControl zoom)
{
ShowAllEdgesLabels(sender as GraphArea, true);
FitToBounds(null, zoom);
_viewmodel.SetVertexPropertiesBinding();
}
public void Draw(AllianceScenario allianceScenario, Powers focus)
{
try
{
_executing = true;
var logicCore = new AllianceScenarioGXLogicCore();
var drawnAllianceScenario = new DrawnAllianceScenario();
drawnAllianceScenario.FocusPower = focus;
drawnAllianceScenario.Populate(allianceScenario);
logicCore.Graph = drawnAllianceScenario;
/*
* logicCore.DefaultLayoutAlgorithm = LayoutAlgorithmTypeEnum.FR;
* logicCore.DefaultLayoutAlgorithmParams = logicCore.AlgorithmFactory.CreateLayoutParameters(LayoutAlgorithmTypeEnum.FR);
* ((FreeFRLayoutParameters)logicCore.DefaultLayoutAlgorithmParams).IdealEdgeLength = 100;
* ((FreeFRLayoutParameters)logicCore.DefaultLayoutAlgorithmParams).RepulsiveMultiplier = 1.5;
* ((FreeFRLayoutParameters)logicCore.DefaultLayoutAlgorithmParams).Seed = 23423423;
*/
logicCore.DefaultLayoutAlgorithm = LayoutAlgorithmTypeEnum.KK;
logicCore.DefaultLayoutAlgorithmParams = logicCore.AlgorithmFactory.CreateLayoutParameters(LayoutAlgorithmTypeEnum.KK);
((KKLayoutParameters)logicCore.DefaultLayoutAlgorithmParams).Width = 1000;
((KKLayoutParameters)logicCore.DefaultLayoutAlgorithmParams).Height = 1000;
((KKLayoutParameters)logicCore.DefaultLayoutAlgorithmParams).AdjustForGravity = true;
////Setup optional params
logicCore.DefaultOverlapRemovalAlgorithmParams =
logicCore.AlgorithmFactory.CreateOverlapRemovalParameters(OverlapRemovalAlgorithmTypeEnum.FSA);
((OverlapRemovalParameters)logicCore.DefaultOverlapRemovalAlgorithmParams).HorizontalGap = 50;
((OverlapRemovalParameters)logicCore.DefaultOverlapRemovalAlgorithmParams).VerticalGap = 50;
//This property sets edge routing algorithm that is used to build route paths according to algorithm logic.
//For ex., SimpleER algorithm will try to set edge paths around vertices so no edge will intersect any vertex.
logicCore.DefaultEdgeRoutingAlgorithm = EdgeRoutingAlgorithmTypeEnum.SimpleER;
//This property sets async algorithms computation so methods like: Area.RelayoutGraph() and Area.GenerateGraph()
//will run async with the UI thread. Completion of the specified methods can be catched by corresponding events:
//Area.RelayoutFinished and Area.GenerateGraphFinished.
logicCore.AsyncAlgorithmCompute = false;
logicCore.EdgeCurvingEnabled = true;
logicCore.EnableParallelEdges = true;
logicCore.ParallelEdgeDistance = 50;
//Finally assign logic core to GraphArea object
GraphArea.LogicCore = logicCore;
GraphArea.SetVerticesDrag(true);
GraphArea.GenerateGraph();
ZoomControl.ZoomToFill();
}
finally
{
_executing = false;
}
}
public EditorObjectManager(GraphArea graphArea, ZoomControl zc)
{
this.graphArea = graphArea;
this.zoomControl = zc;
this.rd = new ResourceDictionary
{
Source = new Uri("pack://application:,,,/View/Templates/EditorTemplate.xaml", UriKind.RelativeOrAbsolute),
};
}
private void ButtonRedrawOnClick(object sender, RoutedEventArgs e)
{
SetupGraphArea();
Area.GenerateGraph(true, true);
Area.SetEdgesDashStyle(EdgeDashStyle.Dash);
Area.ShowAllEdgesArrows(false);
Area.ShowAllEdgesLabels(true);
ZoomControl.ZoomToFill();
}
private void Tsmi_CustomZoom_Click(object sender, EventArgs e)
{
// Set's the custom zoom level of the code editor. The ToolStripMenuItem Tag contains the zoom value.
ToolStripMenuItem clickedItem = (ToolStripMenuItem)sender;
rt_CodeEditor.ZoomFactor = ZoomControl.SetZoom(ZoomState.Custom, rt_CodeEditor.ZoomFactor,
float.Parse(clickedItem.Tag.ToString()));
Sddb_zoom.Text = ZoomControl.GetZoomString(rt_CodeEditor.ZoomFactor);
}
/// <summary>
/// The basic constructor
/// </summary>
/// <param name="graphArea"></param>
/// <param name="zoomControl"></param>
public EditorObjectManager(GraphArea graphArea, ZoomControl zoomControl)
{
this.graphArea = graphArea;
this.zoomControl = zoomControl;
zoomControl.MouseMove += ZoomControlMouseMove;
resourceDictionary = new ResourceDictionary
{
Source = new Uri("pack://application:,,,/ControlsLibrary;component/View/Templates/EditorTemplates.xaml", UriKind.RelativeOrAbsolute)
};
}
protected virtual void drag_Started(DragListener drag)
{
Line al = ExtendedItem.View as Line;
CurrentX2 = al.X2;
CurrentY2 = al.Y2;
CurrentLeft = (double)al.GetValue(Canvas.LeftProperty);
CurrentTop = (double)al.GetValue(Canvas.TopProperty);
var designPanel = ExtendedItem.Services.DesignPanel as DesignPanel;
zoom = designPanel.TryFindParent<ZoomControl>();
if (resizeBehavior != null)
operation = PlacementOperation.Start(extendedItemArray, PlacementType.Resize);
else
{
changeGroup = this.ExtendedItem.Context.OpenGroup("Resize", extendedItemArray);
}
_isResizing = true;
(drag.Target as UserControlPointsObjectThumb).IsPrimarySelection = false;
}
void SetOperation()
{
var designPanel = ExtendedItem.Services.DesignPanel as DesignPanel;
_zoom = designPanel.TryFindParent<ZoomControl>();
if (resizeBehavior != null)
operation = PlacementOperation.Start(extendedItemArray, PlacementType.Resize);
else
{
changeGroup = ExtendedItem.Context.OpenGroup("Resize", extendedItemArray);
}
_isResizing = true;
}
void SetOperation()
{
var designPanel = ExtendedItem.Services.DesignPanel as DesignPanel;
_zoom = designPanel.TryFindParent<ZoomControl>();
CommitOrAbortKeyboardOperation();
//Move a Virtual Design Item arround... (for Snaplines, raster, ...)
//And Resfresh the Points after Positioning that Item!
//if (resizeBehavior != null)
operation = PlacementOperation.Start(extendedItemArray, PlacementType.MovePoint);
// else
// {
// changeGroup = ExtendedItem.Context.OpenGroup("Resize", extendedItemArray);
// }
_isResizing = true;
}
void Awake() {
LookDirection = transform.forward;
zoomControl = ZoomControl.Keys;
}
