private void graphControl_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState, PointF mousePosition)
{
foreach (var pane in GraphPanes)
{
pane.EnsureYMin();
}
}
/// <summary>
/// МАСШТАБ СОБЫТИЕ.
/// </summary>
/// <param name="sender"></param>
/// <param name="oldState"></param>
/// <param name="newState"></param>
static void zc_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
// enforce value constraints
var xs = sender.GraphPane.XAxis.Scale;
var ys = sender.GraphPane.YAxis.Scale;
double xw = xs.Max - xs.Min;
double yw = ys.Max - ys.Min;
double XW = X1 - X0;
double YW = Y1 - Y0;
bool ch = false;
if (yw >= YW) // DUMB USER is not allowed to scale out of range
{
if (YW > 0)
{
ys.Min = Y0;
ys.Max = Y1;
}
else
{
ys.MinAuto = ys.MaxAuto = true;
}
sender.IsEnableVZoom = sender.IsEnableVPan = false;
ch = true;
}
// update
if (ch)
{
sender.AxisChange(); sender.Invalidate();
}
}
private void Zoom()
{
// Vector3 position = camera.transform.localPosition;
state = CalculateZoomState();
switch (state)
{
case ZoomState.ZoomIn:
camera.orthographicSize -= zoomSpeed;
break;
case ZoomState.ZoomOut:
camera.orthographicSize += zoomSpeed;
break;
case ZoomState.Stay:
break;
default:
throw new ArgumentOutOfRangeException();
}
if (camera.orthographicSize < minZoom)
{
camera.orthographicSize = minZoom;
}
if (camera.orthographicSize > maxZoom)
{
camera.orthographicSize = maxZoom;
}
}
private void xxxGraph_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
ZedGraphControl zgc = (ZedGraphControl)sender;
zgc.AxisChange();
zgc.Invalidate();
}
private ZoomState CalculateZoomState()
{
ZoomState state = ZoomState.ZoomIn;
float correctedZoomInBorders = zoomInBorders / 2f;
float correctedZoomOutBorders = zoomOutBorders / 2f;
for (int i = 0; i < followedObjects.Count; i++)
{
if (followedObjects[i] != null)
{
Vector3 viewPoint = camera.WorldToViewportPoint(followedObjects[i].position);
Rect innerRect = new Rect(correctedZoomInBorders, correctedZoomInBorders, 1 - zoomInBorders, 1 - zoomInBorders);
Rect outerRect = new Rect(correctedZoomOutBorders, correctedZoomOutBorders, 1 - zoomOutBorders, 1 - zoomOutBorders);
if (!innerRect.Contains(viewPoint))
{
state = ZoomState.Stay;
}
if (!outerRect.Contains(viewPoint))
{
state = ZoomState.ZoomOut;
return(state);
}
}
}
return(state);
}
private void zedGraphControl2_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
GraphPane pane = sender.GraphPane;
pane.XAxis.Scale.Min = 0;
pane.YAxis.Scale.Max = M0 * 1.5;
}
private void GC_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
var g1 = GC.MasterPane[0];
var g2 = GC.MasterPane[1];
DateTime d0 = new XDate(g1.XAxis.Scale.Min);
DateTime d1 = new XDate(g1.XAxis.Scale.Max);
DateTime d2 = new XDate(g2.XAxis.Scale.Min);
DateTime d3 = new XDate(g2.XAxis.Scale.Max);
var ts1 = d1 - d0;
var ts2 = d3 - d2;
if (ts1.TotalSeconds < ts2.TotalSeconds)
{
g2.XAxis.Scale.Min = g1.XAxis.Scale.Min;
g2.XAxis.Scale.Max = g1.XAxis.Scale.Max;
SetXStep(ts1.TotalSeconds, g1);
SetXStep(ts1.TotalSeconds, g2);
}
else
{
g1.XAxis.Scale.Min = g2.XAxis.Scale.Min;
g1.XAxis.Scale.Max = g2.XAxis.Scale.Max;
SetXStep(ts2.TotalSeconds, g1);
SetXStep(ts2.TotalSeconds, g2);
}
}
public LevelPresenter(PresenterManager pm, EditorPresenter editor, Level level)
{
_pm = pm;
_pm.InstanceRegistered += PresenterRegsitered;
_pm.InstanceUnregistered += PresenterUnregistered;
_editor = editor;
_level = level;
_zoom = new ZoomState();
_zoom.ZoomLevelChanged += ZoomStateLevelChanged;
_info = new LevelInfoPresenter(this);
_layerPresenters = new Dictionary <Guid, LevelLayerPresenter>();
_history = new CommandHistory();
_history.HistoryChanged += HistoryChangedHandler;
_annotations = new ObservableCollection <Annotation>();
InitializeCommandManager();
InitializeLayerHierarchy();
InitializeLayers();
}
//initialization
void Start ()
{
thisState = ZoomState.start;
zoomTotem = gameObject.GetComponent<Animator> ();
}
/// <summary>
/// Handler for the "Set Scale to Default" context menu item. Sets the scale ranging to
/// full auto mode for all axes.
/// </summary>
/// <remarks>
/// This method differs from the <see cref="ZoomOutAll" /> method in that it sets the scales
/// to full auto mode. The <see cref="ZoomOutAll" /> method sets the scales to their initial
/// setting prior to any user actions (which may or may not be full auto mode).
/// </remarks>
/// <param name="primaryPane">The <see cref="GraphPane" /> object which is to have the
/// scale restored</param>
public void RestoreScale(GraphPane primaryPane)
{
if (primaryPane != null)
{
//Go ahead and save the old zoomstates, which provides an "undo"-like capability
//ZoomState oldState = primaryPane.ZoomStack.Push( primaryPane, ZoomState.StateType.Zoom );
ZoomState oldState = new ZoomState(primaryPane, ZoomState.StateType.Zoom);
using (Graphics g = this.CreateGraphics())
{
if (_isSynchronizeXAxes || _isSynchronizeYAxes)
{
foreach (GraphPane pane in _masterPane._paneList)
{
pane.ZoomStack.Push(pane, ZoomState.StateType.Zoom);
ResetAutoScale(pane, g);
}
}
else
{
primaryPane.ZoomStack.Push(primaryPane, ZoomState.StateType.Zoom);
ResetAutoScale(primaryPane, g);
}
// Provide Callback to notify the user of zoom events
if (this.ZoomEvent != null)
{
this.ZoomEvent(this, oldState, new ZoomState(primaryPane, ZoomState.StateType.Zoom));
}
//g.Dispose();
}
Refresh();
}
}
private void ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
if (m_bnegativeerrorval)
{
if (m_bDBF)
{
if (sender.GraphPane.YAxis.Scale.Min == 3e-4)
{
m_biszoomed = false;
return;
}
}
else if (m_bisQfour)
{
if (sender.GraphPane.YAxis.Scale.Min == 1e-12)
{
m_biszoomed = false;
return;
}
}
else
{
if (sender.GraphPane.YAxis.Scale.Min == 1e-11)
{
m_biszoomed = false;
return;
}
}
m_biszoomed = true;
}
}
// Fit to selected zoom
protected virtual void FitToZoom(ZoomState zoomState)
{
var rc = this.ClipSize;
var dataSize = this.GetDataSize();
if (rc.IsZero || dataSize.IsZero)
{
ZoomNeedsUpdate = true;
return;
}
ZoomNeedsUpdate = false;
dataSize = new Size(dataSize.Width + 2, dataSize.Height + 2);
switch (zoomState)
{
case ZoomState.FitToScreen:
_zoomFactor = Math.Min(
rc.Width / dataSize.Width,
rc.Height / dataSize.Height);
break;
case ZoomState.FitToWidth:
_zoomFactor = rc.Width / dataSize.Width;
break;
case ZoomState.FitToHeigth:
_zoomFactor = rc.Height / dataSize.Height;
break;
case ZoomState.Original:
_zoomFactor = 1.0f;
break;
}
}
void MSGraphControl_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState, PointF mousePosition)
{
MSGraphPane pane = MasterPane.FindChartRect(mousePosition) as MSGraphPane;
if (pane == null)
{
mousePosition = PointToClient(new Point(ContextMenuStrip.Left, ContextMenuStrip.Top));
}
pane = MasterPane.FindChartRect(mousePosition) as MSGraphPane;
if (pane == null)
{
return;
}
Graphics g = CreateGraphics();
pane.SetScale(g);
if (IsSynchronizeXAxes)
{
foreach (MSGraphPane syncPane in MasterPane.PaneList)
{
if (syncPane == pane)
{
continue;
}
syncPane.SetScale(g);
}
}
Refresh();
}
/// <summary>
/// Handler for the "Undo All Zoom/Pan" context menu item. Restores the scale ranges to the values
/// before all zoom and pan operations
/// </summary>
/// <remarks>
/// This method differs from the <see cref="RestoreScale" /> method in that it sets the scales
/// to their initial setting prior to any user actions. The <see cref="RestoreScale" /> method
/// sets the scales to full auto mode (regardless of what the initial setting may have been).
/// </remarks>
/// <param name="primaryPane">The <see cref="GraphPane" /> object which is to be zoomed out</param>
public void ZoomOutAll(GraphPane primaryPane)
{
if (primaryPane != null && !primaryPane.ZoomStack.IsEmpty)
{
ZoomState.StateType type = primaryPane.ZoomStack.Top.Type;
ZoomState oldState = new ZoomState(primaryPane, type);
//ZoomState newState = pane.ZoomStack.PopAll( pane );
ZoomState newState = null;
if (_isSynchronizeXAxes || _isSynchronizeYAxes)
{
foreach (GraphPane pane in _masterPane._paneList)
{
ZoomState state = pane.ZoomStack.PopAll(pane);
if (pane == primaryPane)
{
newState = state;
}
}
}
else
{
newState = primaryPane.ZoomStack.PopAll(primaryPane);
}
// Provide Callback to notify the user of zoom events
if (this.ZoomEvent != null)
{
this.ZoomEvent(this, oldState, newState);
}
Refresh();
}
}
/// <summary>
/// Обработчик события при изменении масштаба
/// </summary>
/// <param name="sender"></param>
/// <param name="oldState"></param>
/// <param name="newState"></param>
void zedGraph_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
GraphPane pane = sender.GraphPane;
// Для простоты примера будем ограничивать масштабирование
// только в сторону уменьшения размера графика
// Проверим интервал для каждой оси и
// при необходимости скорректируем его
if (pane.XAxis.Scale.Min <= -100)
{
pane.XAxis.Scale.Min = -100;
}
if (pane.XAxis.Scale.Max >= 100)
{
pane.XAxis.Scale.Max = 100;
}
if (pane.YAxis.Scale.Min <= -1)
{
pane.YAxis.Scale.Min = -1;
}
if (pane.YAxis.Scale.Max >= 2)
{
pane.YAxis.Scale.Max = 2;
}
}
void Update()
{
if (curState != PointerState.Idle)
{
if (zoomTimer >= zoomDetectTime)
{
if (curState == PointerState.Entering)
{
curZoomState = ZoomState.ZoomedIn;
}
else
{
curZoomState = ZoomState.ZoomedOut;
}
curState = PointerState.Idle;
zoomTimer = 0;
if (curZoomState == ZoomState.ZoomedIn)
{
CameraManager.Instance.ControlRoomCam.transform.position = camZoomPos;
Debug.Log("Zoomed in");
}
else
{
//zoom out
CameraManager.Instance.ControlRoomCam.transform.position = Vector3.zero;
Debug.Log("Zoomed out");
}
}
zoomTimer += Time.deltaTime;
}
}
protected void ZedGraphControlPrime_ZoomScaler(ZedGraphControl sender, ZoomState z1, ZoomState z2)
{
z2.ApplyState(this.GraphPane);
double d = this.GraphPane.XAxis.Scale.Max - this.GraphPane.XAxis.Scale.Min;
this.GraphPane.XAxis.Scale.Format = "yyyy";
if (d < 1000)
{
this.GraphPane.XAxis.Title.Text = "Year";
this.GraphPane.XAxis.Scale.Format = "yyyy-MM";
}
if (d < 150)
{
this.GraphPane.XAxis.Title.Text = "Year";
this.GraphPane.XAxis.Scale.Format = "yyyy-MM-dd";
}
if (d < 3)
{
this.GraphPane.XAxis.Title.Text = ((XDate)this.GraphPane.XAxis.Scale.Min).DateTime.Date.ToString("yyyy-MM-dd");
this.GraphPane.XAxis.Scale.Format = "HH";
}
if (d < .3)
{
this.GraphPane.XAxis.Title.Text = ((XDate)this.GraphPane.XAxis.Scale.Min).DateTime.Date.ToString("yyyy-MM-dd");
this.GraphPane.XAxis.Scale.Format = "HH:mm";
}
}
private void zgcScan_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
if (changing)
{
return;
}
changing = true;
try
{
if (tvMRM.SelectedNode.Level == 1)
{
return;
}
foreach (GraphPane pane in zgcPeptide.MasterPane.PaneList)
{
newState.ApplyState(pane);
}
}
finally
{
changing = false;
}
}
public bool JoinZoom(string meetingID, string meetingPSW)
{
TimeSpan timeoutForGUIFunctions = TimeSpan.FromSeconds(15);
TimeSpan timeoutForZoomStart = TimeSpan.FromSeconds(30);
StartZoom();
OpenZoomJoinMenu(timeoutForZoomStart);
ZoomEnterIDAndJoin(timeoutForGUIFunctions, meetingID);
ZoomState currentState = GetZoomStateAfterJoin(timeoutForGUIFunctions);
if (currentState == ZoomState.PasswordRequired)
{
ZoomEnterPasswordAndJoin(meetingPSW, timeoutForGUIFunctions);
currentState = ZoomWaitUntilStateIsNot(ZoomState.PasswordRequired, timeoutForGUIFunctions);
}
if (currentState == ZoomState.CamPreviewWindow)
{
ZoomSkipCameraDialog(timeoutForGUIFunctions);
currentState = ZoomWaitUntilStateIsNot(ZoomState.CamPreviewWindow, timeoutForGUIFunctions);
}
return(currentState == ZoomState.JoinedMeeting);
}
/* Player toggled camera, update the state and play the right sound. */
public void toggleZoom()
{
lerp_timer = 0;
switch (zState)
{
case ZoomState.ZOOMING_OUT:
zState = ZoomState.ZOOMING_IN;
zoomInSound.Play();
break;
case ZoomState.ZOOMED_OUT:
zState = ZoomState.ZOOMING_IN;
zoomInSound.Play();
break;
case ZoomState.ZOOMING_IN:
zState = ZoomState.ZOOMING_OUT;
zoomOutSound.Play();
break;
case ZoomState.ZOOMED_IN:
zState = ZoomState.ZOOMING_OUT;
zoomOutSound.Play();
break;
}
}
/// <summary>
/// Focuses the plot on a specific point. This is used for when the user clicks the fragment ladder and we want to hilight that point
/// </summary>
/// <param name="focusValue">The x value to focus on in the plot</param>
public void FocusPlotOnPoint(double focusValue)
{
var arrowPoint = msPlot.m_arrowPoint;
if (msPlot.m_arrowShowing && Math.Abs((float)focusValue - arrowPoint.X) < Single.Epsilon)
{
msPlot.m_arrowShowing = false;
}
else
{
int offset = msPlot.m_options.focusOffset;
//change the zoom of the graph
ZoomState oldZoom = new ZoomState(msPlot.GraphPane, ZoomState.StateType.Zoom);
msPlot.GraphPane.XAxis.Scale.Min = focusValue - offset;
msPlot.GraphPane.XAxis.Scale.Max = focusValue + offset;
msPlot.GraphPane.YAxis.Scale.MinAuto = true;
msPlot.GraphPane.YAxis.Scale.MaxAuto = true;
msPlot.GraphPane.ZoomStack.Add(oldZoom);
//place a cursor below the axis
PointF graphPoint = new PointF((float)focusValue, (float)msPlot.GraphPane.YAxis.Scale.Min);
msPlot.PaintArrow(graphPoint);
}
msPlot.Invalidate();
}
private void tryToFindTargetForZoomingIn()
{
//check if we can find a die under the mouse pointer
RaycastHit info;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
bool infoFound = Physics.Raycast(ray, out info);
Die dieFound = infoFound ? info.transform.GetComponent <Die>() : null;
if (infoFound && dieFound && (_zoomInOnARollingDieAllowed || !dieFound.isRolling))
{
//get the position
_endPosition = info.transform.position + Vector3.up * _zoomDistance;
//get the rotation by first getting an orientation vector from camera to die
Vector3 forward = info.transform.position - _camera.transform.position;
Quaternion forwardRotation = Quaternion.LookRotation(forward);
//then rotate THAT vector downward to Vector3.down, gives a nicer camera orientation
Quaternion downwardRotation = Quaternion.FromToRotation(forward, Vector3.down) * forwardRotation;
_endRotation = downwardRotation;
//start over with the interpolation
_interpolationAlpha = 0;
_zoomState = ZoomState.ZOOMING_IN;
//set the current zoom die
_lastZoomedDie = dieFound;
}
/*
* else
* {
* Debug.Log("Could not find target");
* }
*/
}
private void Zoom(ZoomState zoom)
{
if (_zoomState == zoom)
{
return;
}
_zoomState = zoom;
switch (zoom)
{
case ZoomState.None:
LoadHistoryEntries();
break;
case ZoomState.Hour:
Zoom(new TimeSpan(0, 1, 0, 0));
break;
case ZoomState.Day:
Zoom(new TimeSpan(1, 0, 0, 0));
break;
case ZoomState.Week:
Zoom(new TimeSpan(7, 0, 0, 0));
break;
case ZoomState.Month:
Zoom(TimeSpan.Zero); //months dont work with a timespan
break;
}
ShowEntries();
FormatDates();
}
/// <summary>
/// Assure the Y value range from 0 to 360.
/// </summary>
/// <param name="sender"></param>
/// <param name="oldState"></param>
/// <param name="newState"></param>
private void zedGeoView_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
sender.GraphPane.YAxis.Scale.Min = 0;
sender.GraphPane.YAxis.Scale.Max = 360;
double xMax = sender.GraphPane.XAxis.Scale.Max;
foreach (GraphObj obj in sender.GraphPane.GraphObjList)
{
if (!(obj is TextObj))
{
continue;
}
TextObj text = obj as TextObj;
LineItem line = (LineItem)curveOf(sender, text.Text);
if (line != null && line.Symbol.Type == SymbolType.None)
{
obj.Location.X = xMax;
int closestIndex = Math.Max(0, (int)(xMax - since.DateTime.ToOADate()));
for (int i = closestIndex; i <= line.NPts; i++)
{
if (line[i].X < xMax)
{
continue;
}
closestIndex = i;
break;
}
obj.Location.Y = line[closestIndex].Y;
}
}
}
public void ZoomIn()
{
thisButton = MenuButton.none;
zoomTotem.SetTrigger("zoomActivate");
title.Zoom();
thisState = ZoomState.totemZoomedIn;
StartCoroutine(WaitASec());
}
public void ZoomOut()
{
thisButton = MenuButton.none;
zoomTotem.SetTrigger("zoomActivate");
title.Zoom();
thisState = ZoomState.start;
ButtonsObj.SetActive(false);
}
//Returns the new state, will throw on timeout
ZoomState ZoomWaitUntilStateIsNot(ZoomState stateNotToBe, TimeSpan timeout)
{
return(Retry.While(() =>
{
return GetZoomStateAfterJoin(timeout);
}, (state) => state == stateNotToBe,
timeout, DefaultIntervalForFunctions, true, true).Result);
}
public override void ScrollUp()
{
if (thisState.Equals(ZoomState.scrolledDown))
{
zoomTotem.SetTrigger("totemScroll");
thisState = ZoomState.totemZoomedIn;
}
}
/// <summary>
/// Fires just afer the form is done zooming. Reevaluates the annotations for the new scale
/// </summary>
/// <param name="sender"></param>
/// <param name="oldState"></param>
/// <param name="newState"></param>
void MyZedGraph_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
if (m_manager.DataLoaded == true)
{
ReevaluateAnnotations();
}
//m_arrowShowing = false;
}
private void UpdateZoomState(ZoomState zoom)
{
if (_trackBarZoom != null && _trackBarZoom.Value != zoom.ZoomIndex)
{
_trackBarZoom.Value = zoom.ZoomIndex;
_statusZoomText.Text = zoom.ZoomText;
}
}
public void Init(string _speciesName, char _speciesType, float _bodySize,
float _startPopulation, float _maxPopulation, float _minPopulation,
GameObject _picture, Color border) {
name = _speciesName;
bodySize = _bodySize;
maxPopulation = _maxPopulation;
minPopulation = _minPopulation;
speciesType = _speciesType;
picture = Instantiate(_picture) as GameObject;
picture.transform.parent = transform;
picture.name = "picture";
zoomState = ZoomState.zoom0;
UpdatePopulation(_startPopulation);
transferredAmounts = new Dictionary<string, float>();
baseSpringZoom0 = gameObject.AddComponent<SpringJoint2D>();
baseSpringZoom0.autoConfigureDistance = false;
baseSpringZoom0.distance = 0.005f;
baseSpringZoom0.dampingRatio = 0.7f;
baseSpringZoom0.frequency = 0.8f;
if (speciesType == 'p') {
// TODO: change this arrangement from random to something similar that minion thing Physics.CheckSphere()
baseSpringZoom0.connectedAnchor = new Vector2(Random.Range(-4f, 4f), -3f);
} else {
baseSpringZoom0.connectedAnchor = new Vector2(Random.Range(-4f, 4f), Mathf.Max(-1f, (Mathf.Log(bodySize)) - 1f));
}
transform.Find("border").gameObject.GetComponent<SpriteRenderer>().color = border;
deathSpringZoom0 = gameObject.AddComponent<SpringJoint2D>();
// TODO: implement the choice of dead animals
deathSpringZoom0.connectedAnchor = new Vector2(7f, 0);
deathSpringZoom0.autoConfigureDistance = false;
deathSpringZoom0.distance = 0.005f;
deathSpringZoom0.dampingRatio = 1f;
deathSpringZoom0.frequency = 2f;
deathSpringZoom0.enabled = false;
interactionSpringsZoom0 = new List<SpringJoint2D>();
baseSpringZoom1 = gameObject.AddComponent<SpringJoint2D>();
baseSpringZoom1.autoConfigureDistance = false;
baseSpringZoom1.distance = 0.005f;
baseSpringZoom1.dampingRatio = 1f;
baseSpringZoom1.frequency = 2f;
baseSpringZoom1.enabled = false;
if (population == 0) {
alive = false;
transform.position = deathSpringZoom0.connectedAnchor;
} else {
alive = true;
transform.position = baseSpringZoom0.connectedAnchor;
}
SetZoom0();
}
void graph_ZoomEvent(ZedGraphControl sender, ZoomState oldState, ZoomState newState)
{
if (sender != graph)
{
return;
}
// TODO: not for every event
RefreshLabels(graph.GraphPane);
}
protected override bool OnMouseDown(MouseEventArgs eventArgs)
{
if (eventArgs.Button == MouseButtons.Left)
{
this.currentState = ((Control.ModifierKeys & Keys.Shift) != 0) ? ((this.initialState == ZoomState.In) ? ZoomState.Out : ZoomState.In) : this.initialState;
bool forwardMessage = (this.fastZoomingMessageFilter == null);
RefreshUIState();
if (forwardMessage && this.fastZoomingMessageFilter != null)
((IWorkflowDesignerMessageSink)this.fastZoomingMessageFilter).OnMouseDown(eventArgs);
}
return true;
}
protected override bool OnKeyDown(KeyEventArgs eventArgs)
{
if (eventArgs.KeyValue == 0x1b)
{
base.ParentView.RemoveDesignerMessageFilter(this);
}
else
{
this.currentState = ((eventArgs.Modifiers & Keys.Shift) != Keys.None) ? ((this.initialState == ZoomState.In) ? ZoomState.Out : ZoomState.In) : this.initialState;
this.RefreshUIState();
}
return true;
}
public static ZoomState Update(int gameTime)
{
buzzCooldown -= gameTime;
if (buzzCooldown < 0)
buzzCooldown = 0;
if (state == ZoomState.None)
{
SelectPlayerRoom();
}
if (state == ZoomState.Sector)
{
Vector3 idealTarget = Engine.sectorList[selectedSectorIndex].center;
if (cameraDistance < roomZoomThreshold)
{
idealTarget = Engine.roomList[selectedRoomIndex].center;
}
Vector3 dif = (idealTarget - cameraTarget);
if (dif.Length() > 4)
{
dif.Normalize();
cameraTarget += .1f * dif * gameTime;
if (Math.Abs(cameraDistance - roomZoomThreshold) > 5)
cameraDistance = (cameraPosition - cameraTarget).Length();
}
}
if (state == ZoomState.Sector && GamePad.GetState(Game1.activePlayer).IsButtonDown(Buttons.LeftTrigger))
{
cameraDistance += .1f * gameTime;
}
if (state == ZoomState.Sector && GamePad.GetState(Game1.activePlayer).IsButtonDown(Buttons.RightTrigger))
{
cameraDistance -= .1f * gameTime;
}
int currentScrollWheel = Mouse.GetState().ScrollWheelValue;
if (state == ZoomState.Sector && currentScrollWheel > Controls.scrollWheelPrev)
{
cameraDistance -= 1.5f * gameTime;
if (cameraDistance < Engine.roomList[selectedRoomIndex].size.Length())
cameraDistance = Engine.roomList[selectedRoomIndex].size.Length();
}
if (state == ZoomState.Sector && currentScrollWheel < Controls.scrollWheelPrev)
{
cameraDistance += 1.5f * gameTime;
if (cameraDistance > 600)
cameraDistance = 600;
}
if ((state == ZoomState.World) && currentScrollWheel > Controls.scrollWheelPrev)
{
cameraDistance -= 2f * gameTime;
if (cameraDistance < 100)
cameraDistance = 100;
}
if ((state == ZoomState.World) && currentScrollWheel < Controls.scrollWheelPrev)
{
cameraDistance += 2f * gameTime;
if (cameraDistance > 900)
cameraDistance = 900;
}
if (state == ZoomState.ZoomToWorld)
{
WorldMap.worldZoomLevel += WorldMap.zoomSpeed * gameTime;
cameraPosition = (1-worldZoomLevel) * sectorCameraPosition + (worldZoomLevel) * worldCameraPosition;
cameraTarget = (1-worldZoomLevel) * sectorCameraTarget + (worldZoomLevel) * worldCameraTarget;
cameraDistance = (1 - worldZoomLevel) * cameraDistance + (worldZoomLevel) * worldCameraDefaultZoom;
if (WorldMap.worldZoomLevel > 1f)
{
WorldMap.worldZoomLevel = 1f;
state = ZoomState.World;
}
}
if (state == ZoomState.ZoomFromWorld)
{
WorldMap.worldZoomLevel -= WorldMap.zoomSpeed * gameTime;
cameraPosition = (1 - worldZoomLevel) * sectorCameraPosition + (worldZoomLevel) * worldCameraPosition;
cameraTarget = (1 - worldZoomLevel) * sectorCameraTarget + (worldZoomLevel) * worldCameraTarget;
cameraDistance = (1 - worldZoomLevel) * sectorCameraDefaultZoom + (worldZoomLevel) * cameraDistance;
if (WorldMap.worldZoomLevel < 0f)
{
WorldMap.worldZoomLevel = 0f;
state = ZoomState.Sector;
Engine.roomList[selectedRoomIndex].roomHighlight = true;
}
}
if (state == ZoomState.ZoomToSector)
{
WorldMap.zoomLevel += WorldMap.zoomSpeed * gameTime;
cameraPosition = (1 - zoomLevel) * playerCameraPosition + (zoomLevel) * sectorCameraPosition;
cameraTarget = (1 - zoomLevel) * playerCameraTarget + (zoomLevel) * sectorCameraTarget;
cameraUp = (1 - zoomLevel) * playerCameraUp + (zoomLevel) * sectorCameraUp;
if (WorldMap.zoomLevel > 1f)
{
//cameraDistance = sectorCameraDefaultZoom;
WorldMap.zoomLevel = 1f;
state = ZoomState.Sector;
if (skipToInventory == true)
state = ZoomState.Inventory;
Engine.reDraw = true;
skipToInventory = false;
}
}
if (state == ZoomState.ZoomFromSector)
{
if(WorldMap.zoomLevel == 1f) Engine.reDraw = true;
WorldMap.zoomLevel -= WorldMap.zoomSpeed * gameTime;
cameraPosition = (1 - zoomLevel) * playerCameraPosition + (zoomLevel) * sectorCameraPosition;
cameraTarget = (1 - zoomLevel) * playerCameraTarget + (zoomLevel) * sectorCameraTarget;
cameraUp = (1 - zoomLevel) * playerCameraUp + (zoomLevel) * sectorCameraUp;
if (WorldMap.zoomLevel < 0f)
{
WorldMap.zoomLevel = 0f;
state = ZoomState.None;
Engine.reDraw = true;
Controls.CenterMouse();
Engine.state = EngineState.Active;
Engine.roomList[selectedRoomIndex].roomHighlight = false;
}
}
return state;
}
public void SetZoom0() {
zoomState = ZoomState.zoom0;
if (alive == true) {
transform.Find("text").GetComponent<TextMesh>().text = "hello";
} else {
transform.Find("text").GetComponent<TextMesh>().text = "byee";
}
ActivateZoom0Springs();
baseSpringZoom1.enabled = false; //TODO: change this into a function for future, zoom2
Resize();
}
public void SetZoom1other(float interaction, GameObject zoomedSpecies) {
zoomState = ZoomState.zoom1other;
transform.Find("text").GetComponent<TextMesh>().text = "hi";
DeactivateZoom0Springs();
baseSpringZoom1.enabled = true;
if (alive == false) {
Vector2 zoom0Anchor = deathSpringZoom0.connectedAnchor;
baseSpringZoom1.connectedAnchor = new Vector2(zoom0Anchor.x + 3, zoom0Anchor.y);
} else {
if (interaction == 0) {
Vector2 zoom0Anchor = baseSpringZoom0.connectedAnchor;
if (bodySize > zoomedSpecies.GetComponent<SpeciesIcon>().bodySize) {
baseSpringZoom1.connectedAnchor = new Vector2(zoom0Anchor.x, zoom0Anchor.y + 10f);
} else {
baseSpringZoom1.connectedAnchor = new Vector2(zoom0Anchor.x, zoom0Anchor.y - 10f);
}
} else if (interaction < 0) {
baseSpringZoom1.connectedAnchor = new Vector2(baseSpringZoom0.connectedAnchor.x,3);
} else if (interaction > 0) {
baseSpringZoom1.connectedAnchor = new Vector2(baseSpringZoom0.connectedAnchor.x,-3);
}
Resize();
}
}
private void UpdateZoom(int zoomLevel, Point center)
{
PointF relativeCenterF = PointF.Empty;
WorkflowView parentView = ParentView;
Point layoutOrigin = parentView.LogicalPointToClient(Point.Empty);
center.X -= layoutOrigin.X; center.Y -= layoutOrigin.Y;
relativeCenterF = new PointF((float)center.X / (float)parentView.HScrollBar.Maximum, (float)center.Y / (float)parentView.VScrollBar.Maximum);
parentView.Zoom = Math.Min(Math.Max(zoomLevel, AmbientTheme.MinZoom), AmbientTheme.MaxZoom);
Point newCenter = new Point((int)((float)parentView.HScrollBar.Maximum * relativeCenterF.X), (int)((float)parentView.VScrollBar.Maximum * relativeCenterF.Y));
parentView.ScrollPosition = new Point(newCenter.X - parentView.HScrollBar.LargeChange / 2, newCenter.Y - parentView.VScrollBar.LargeChange / 2);
this.currentState = ((Control.ModifierKeys & Keys.Shift) != 0) ? ((this.initialState == ZoomState.In) ? ZoomState.Out : ZoomState.In) : this.initialState;
RefreshUIState();
}
/// <summary>
/// Clear the collection of saved states.
/// </summary>
private void ZoomStateClear()
{
_zoomStateStack.Clear();
_zoomState = null;
}
/// <summary>
///
/// </summary>
private void InitializeDrawable()
{
var context = this.DataContext as EditorContext;
if (context == null)
return;
context.Invalidate =
() =>
{
InitializeLayers();
ResizeDrawable();
var container = context.Editor.Project.CurrentContainer;
if (container != null)
{
container.Invalidate();
}
};
_state = new ZoomState(context);
context.Commands.ZoomResetCommand =
Command.Create(
() =>
{
_state.ResetZoom();
if (context.Invalidate != null)
{
context.Invalidate();
}
},
() => true);
context.Commands.ZoomExtentCommand =
Command.Create(
() =>
{
_state.AutoFit();
if (context.Invalidate != null)
{
context.Invalidate();
}
},
() => true);
this.PointerPressed +=
(sender, e) =>
{
if (_state == null)
return;
var p = e.GetPosition(this);
if (e.MouseButton == MouseButton.Middle)
{
_state.MiddleDown(p.X, p.Y);
// TODO: this.Cursor = Cursors.Pointer;
}
if (e.MouseButton == MouseButton.Left)
{
this.Focus();
_state.PrimaryDown(p.X, p.Y);
}
if (e.MouseButton == MouseButton.Right)
{
this.Focus();
_state.AlternateDown(p.X, p.Y);
}
};
this.PointerReleased +=
(sender, e) =>
{
if (_state == null)
return;
var p = e.GetPosition(this);
if (e.MouseButton == MouseButton.Middle)
{
this.Focus();
_state.MiddleUp(p.X, p.Y);
// TODO: this.Cursor = Cursors.Default;
}
if (e.MouseButton == MouseButton.Left)
{
this.Focus();
_state.PrimaryUp(p.X, p.Y);
}
if (e.MouseButton == MouseButton.Right)
{
this.Focus();
_state.AlternateUp(p.X, p.Y);
}
};
this.PointerMoved +=
(sender, e) =>
{
if (_state == null)
return;
var p = e.GetPosition(this);
_state.Move(p.X, p.Y);
};
this.PointerWheelChanged +=
(sender, e) =>
{
if (_state == null)
return;
var p = e.GetPosition(this);
_state.Wheel(p.X, p.Y, e.Delta.Y);
};
}
/// <summary>
/// Save the current states of the GraphPanes to a separate collection. Save a single
/// (<see paramref="primaryPane" />) GraphPane if the panes are not synchronized
/// (see <see cref="IsSynchronizeXAxes" /> and <see cref="IsSynchronizeYAxes" />),
/// or save a list of states for all GraphPanes if the panes are synchronized.
/// </summary>
/// <param name="primaryPane">The primary GraphPane on which zoom/pan/scroll operations
/// are taking place</param>
/// <param name="type">The <see cref="ZoomState.StateType" /> that describes the
/// current operation</param>
/// <returns>The <see cref="ZoomState" /> that corresponds to the
/// <see paramref="primaryPane" />.
/// </returns>
private ZoomState ZoomStateSave(GraphPane primaryPane, ZoomState.StateType type)
{
ZoomStateClear();
if (_isSynchronizeXAxes || _isSynchronizeYAxes)
{
foreach (GraphPane pane in _masterPane._paneList)
{
ZoomState state = new ZoomState(pane, type);
if (pane == primaryPane)
_zoomState = state;
_zoomStateStack.Add(state);
}
}
else
_zoomState = new ZoomState(primaryPane, type);
return _zoomState;
}
private void UpdateZoom(int zoomLevel, Point center)
{
PointF empty = PointF.Empty;
WorkflowView parentView = base.ParentView;
Point point = parentView.LogicalPointToClient(Point.Empty);
center.X -= point.X;
center.Y -= point.Y;
empty = new PointF(((float) center.X) / ((float) parentView.HScrollBar.Maximum), ((float) center.Y) / ((float) parentView.VScrollBar.Maximum));
parentView.Zoom = Math.Min(Math.Max(zoomLevel, 10), 400);
Point point2 = new Point((int) (parentView.HScrollBar.Maximum * empty.X), (int) (parentView.VScrollBar.Maximum * empty.Y));
parentView.ScrollPosition = new Point(point2.X - (parentView.HScrollBar.LargeChange / 2), point2.Y - (parentView.VScrollBar.LargeChange / 2));
this.currentState = ((Control.ModifierKeys & Keys.Shift) != Keys.None) ? ((this.initialState == ZoomState.In) ? ZoomState.Out : ZoomState.In) : this.initialState;
this.RefreshUIState();
}
/// <summary>
/// Handler for the "Undo All Zoom/Pan" context menu item. Restores the scale ranges to the values
/// before all zoom and pan operations
/// </summary>
/// <remarks>
/// This method differs from the <see cref="RestoreScale" /> method in that it sets the scales
/// to their initial setting prior to any user actions. The <see cref="RestoreScale" /> method
/// sets the scales to full auto mode (regardless of what the initial setting may have been).
/// </remarks>
/// <param name="primaryPane">The <see cref="GraphPane" /> object which is to be zoomed out</param>
public void ZoomOutAll( GraphPane primaryPane )
{
if ( primaryPane != null && !primaryPane.ZoomStack.IsEmpty )
{
ZoomState.StateType type = primaryPane.ZoomStack.Top.Type;
ZoomState oldState = new ZoomState( primaryPane, type );
//ZoomState newState = pane.ZoomStack.PopAll( pane );
ZoomState newState = null;
if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
{
foreach ( GraphPane pane in _masterPane._paneList )
{
ZoomState state = pane.ZoomStack.PopAll( pane );
if ( pane == primaryPane )
newState = state;
}
}
else
newState = primaryPane.ZoomStack.PopAll( primaryPane );
// Provide Callback to notify the user of zoom events
if ( this.ZoomEvent != null )
this.ZoomEvent( this, oldState, newState );
Refresh();
}
}
// DEBUG ----------------------------------------
//public void OnGUI()
//{
// if (GameState.Instance.inGame())
// {
// GUILayout.Label(Input.mousePosition.ToString());
// GUILayout.Label(Input.GetAxis("Mouse X").ToString() + " " + Input.GetAxis("Mouse Y").ToString());
// }
//}
public void Start()
{
// disable mouse cursor
Cursor.visible = false;
zoomState = gameObject.GetComponent<ZoomState>();
if (crosshairImage == null)
{
Debug.LogError("Crosshair texture for ChaseState is not set!");
}
}
protected override bool OnKeyUp(KeyEventArgs eventArgs)
{
this.currentState = ((eventArgs.Modifiers & Keys.Shift) != 0) ? ((this.initialState == ZoomState.In) ? ZoomState.Out : ZoomState.In) : this.initialState;
RefreshUIState();
return true;
}
void HandleZoom()
{
if (Zooming && Input.GetKeyUp(KeyCode.LeftShift)) {
if (GetZoomInKey) { Trigger(OnZoomInEnd); }
if (GetZoomOutKey) { Trigger(OnZoomOutEnd); }
zooming = ZoomState.NONE;
return;
}
if (ZoomingIn && Input.GetKey(KeyCode.LeftShift) && GetZoomInKey) {
Trigger(OnZoomInProgress);
return;
}
if (ZoomingOut && Input.GetKey(KeyCode.LeftShift) && GetZoomOutKey) {
Trigger(OnZoomOutProgress);
return;
}
if (UndefinedZooming && Input.GetKey(KeyCode.LeftShift) && !GetZoomInKey && !GetZoomOutKey) {
Trigger(OnZoomProgress);
return;
}
if (Input.GetKeyDown(KeyCode.LeftShift)) {
Trigger(OnZoomStart);
zooming = ZoomState.ZOOMING;
return;
}
if (!ZoomingIn && GetZoomInKey) {
Trigger(OnZoomInStart);
zooming = ZoomState.ZOOMING_IN;
return;
}
if (!ZoomingOut && GetZoomOutKey) {
Trigger(OnZoomOutStart);
zooming = ZoomState.ZOOMING_OUT;
return;
}
}
internal ZoomingMessageFilter(bool initiateZoomIn)
{
this.currentState = this.initialState = (initiateZoomIn) ? ZoomState.In : ZoomState.Out;
}
/// <summary>
/// Default Constructor
/// </summary>
public ZeeGraphControl()
{
_dragPane = null;
InitializeComponent();
// Use double-buffering for flicker-free updating:
SetStyle(ControlStyles.UserPaint |
ControlStyles.AllPaintingInWmPaint |
ControlStyles.DoubleBuffer |
ControlStyles.ResizeRedraw, true);
SetStyle(ControlStyles.SupportsTransparentBackColor, true);
_resourceManager = new ResourceManager("ZeeGraph.ZeeGraphLocale",
Assembly.GetExecutingAssembly());
Rectangle rect = new Rectangle(0, 0, Size.Width, Size.Height);
_masterPane = new MasterPane("", rect);
_masterPane.Margin.All = 0;
_masterPane.Title.IsVisible = false;
string titleStr = _resourceManager.GetString("title_def");
string xStr = _resourceManager.GetString("x_title_def");
string yStr = _resourceManager.GetString("y_title_def");
GraphPane graphPane = new GraphPane(rect, titleStr, xStr, yStr);
using (Graphics g = CreateGraphics())
{
graphPane.AxisChange(g);
//g.Dispose();
}
_masterPane.Add(graphPane);
hScrollBar1.Minimum = 0;
hScrollBar1.Maximum = 100;
hScrollBar1.Value = 0;
vScrollBar1.Minimum = 0;
vScrollBar1.Maximum = 100;
vScrollBar1.Value = 0;
_xScrollRange = new ScrollRange(true);
_yScrollRangeList = new ScrollRangeList();
_y2ScrollRangeList = new ScrollRangeList();
_yScrollRangeList.Add(new ScrollRange(true));
_y2ScrollRangeList.Add(new ScrollRange(false));
_zoomState = null;
_zoomStateStack = new ZoomStateStack();
}
internal void FireZoomEvent(ZoomState zoomState, EventArgs e)
{
if (_onZoom != null)
_onZoom(this, CreateAxisZoomEventArgs(zoomState, e));
}
/// <summary>
/// Initialize <see cref="ZoomState"/> object
/// </summary>
private void InitializeState()
{
var context = this.DataContext as EditorContext;
if (context == null)
return;
context.Editor.Invalidate = () => this.InvalidateVisual();
_state = new ZoomState(context.Editor);
if (context.Renderers != null && context.Renderers[0].State.EnableAutofit)
{
AutoFit(this.Bounds.Width, this.Bounds.Height);
}
this.PointerPressed +=
(sender, e) =>
{
if (_state == null)
return;
var p = e.GetPosition(this);
if (e.MouseButton == MouseButton.Left)
{
this.Focus();
_state.LeftDown(p.X, p.Y);
}
if (e.MouseButton == MouseButton.Right)
{
this.Cursor = new Cursor(StandardCursorType.Hand);
this.Focus();
_state.RightDown(p.X, p.Y);
}
};
this.PointerReleased +=
(sender, e) =>
{
if (_state == null)
return;
var p = e.GetPosition(this);
if (e.MouseButton == MouseButton.Left)
{
this.Focus();
_state.LeftUp(p.X, p.Y);
}
if (e.MouseButton == MouseButton.Right)
{
this.Cursor = new Cursor(StandardCursorType.Arrow);
this.Focus();
_state.RightUp(p.X, p.Y);
}
};
this.PointerMoved +=
(sender, e) =>
{
if (_state == null)
return;
var p = e.GetPosition(this);
_state.Move(p.X, p.Y);
};
this.PointerWheelChanged +=
(sender, e) =>
{
if (_state == null)
return;
if (context == null || context.Editor == null || context.Editor.Project == null)
return;
var container = context.Editor.Project.CurrentContainer;
if (container == null)
return;
var p = e.GetPosition(this);
_state.Wheel(
p.X,
p.Y,
e.Delta.Y,
this.Bounds.Width,
this.Bounds.Height,
container.Template.Width,
container.Template.Height);
};
}
// TODO: HERE TOO
public void PullFromGraveyard() {
alive = true;
zoomState = ZoomState.zoom0;
//baseSpringZoom0.enabled = true;
//deathSpringZoom0.enabled = false;
}
public override void UpKey ()
{
switch (thisState) {
case ZoomState.start:
ZoomIn();
break;
case ZoomState.totemZoomedIn:
thisButton--;
switch (thisButton) {
case (MenuButton.underflow):
case(MenuButton.none):
thisButton = MenuButton.quit;
zoomTotem.SetTrigger ("totemScroll");
thisState = ZoomState.scrolledDown;
break;
case(MenuButton.startGame):
break;
case(MenuButton.resumeGame):
break;
case(MenuButton.options):
break;
case(MenuButton.quit):
break;
}
break;
case ZoomState.scrolledDown:
thisButton--;
switch (thisButton) {
case(MenuButton.none):
break;
case(MenuButton.startGame):
zoomTotem.SetTrigger ("totemScroll");
thisState = ZoomState.totemZoomedIn;
break;
case(MenuButton.resumeGame):
zoomTotem.SetTrigger ("totemScroll");
if (thisState.Equals (ZoomState.totemZoomedIn))
thisState = ZoomState.scrolledDown;
else if (thisState.Equals (ZoomState.scrolledDown))
thisState = ZoomState.totemZoomedIn;
break;
case(MenuButton.options):
break;
case(MenuButton.quit):
break;
}
break;
}
}
public void SetZoom1main(float birthRate, float selfInteraction) {
zoomState = ZoomState.zoom1main;
transform.Find("text").GetComponent<TextMesh>().text = name + "\npopulation: " + population + "\nweight: " + bodySize + "\nbirthrate: " + birthRate;
transform.localRotation = Quaternion.identity;
DeactivateZoom0Springs();
baseSpringZoom1.enabled = true;
baseSpringZoom1.connectedAnchor = new Vector2(0,0);
Resize();
// TODO: make this change in size smoooooth
}
public override void ScrollUp ()
{
if (thisState.Equals (ZoomState.scrolledDown)) {
zoomTotem.SetTrigger ("totemScroll");
thisState = ZoomState.totemZoomedIn;
}
}
public void ZoomIn ()
{
thisButton = MenuButton.none;
zoomTotem.SetTrigger ("zoomActivate");
title.Zoom();
thisState = ZoomState.totemZoomedIn;
StartCoroutine(WaitASec());
}
public void ZoomOut ()
{
thisButton = MenuButton.none;
zoomTotem.SetTrigger ("zoomActivate");
title.Zoom ();
thisState = ZoomState.start;
ButtonsObj.SetActive(false);
}
public static void ZoomToSector()
{
UnHightlightSector();
worldZoomLevel = 0;
zoomLevel = 0;
cameraTarget = playerCameraTarget = Engine.player.cameraTarget;
cameraPosition = playerCameraPosition = Engine.player.cameraPos;
cameraUp = playerCameraUp = Engine.player.cameraUp;
for (int i = 0; i < Engine.roomList.Count; i++)
{
if (Engine.roomList[i] == Engine.player.currentRoom)
{
selectedRoomIndex = i;
Engine.player.currentRoom.roomHighlight = true;
}
}
for (int i = 0; i < Engine.sectorList.Count; i++)
{
if (Engine.roomList[selectedRoomIndex].parentSector == Engine.sectorList[i])
{
selectedSectorIndex = i;
}
}
sectorCameraUp = Engine.player.up;
sectorCameraTarget = Engine.sectorList[selectedSectorIndex].center;
Vector3 dif = Engine.player.center.normal + 1.1f * Engine.player.up + 1.4f * Engine.player.right;
dif.Normalize();
cameraDistance = sectorCameraDefaultZoom;
sectorCameraPosition = sectorCameraTarget + dif * cameraDistance;
state = ZoomState.ZoomToSector;
zoomToPlayer = false;
displayMouse = false;
}
internal AxisZoomEventArgs CreateAxisZoomEventArgs(ZoomState zoomState, EventArgs e)
{
AxisZoomEventArgs eventArgs = new AxisZoomEventArgs(e);
eventArgs.MinValue = zoomState.MinXValue;
eventArgs.MaxValue = zoomState.MaxXValue;
return eventArgs;
}
/// <summary>
/// Handler for the "Set Scale to Default" context menu item. Sets the scale ranging to
/// full auto mode for all axes.
/// </summary>
/// <remarks>
/// This method differs from the <see cref="ZoomOutAll" /> method in that it sets the scales
/// to full auto mode. The <see cref="ZoomOutAll" /> method sets the scales to their initial
/// setting prior to any user actions (which may or may not be full auto mode).
/// </remarks>
/// <param name="primaryPane">The <see cref="GraphPane" /> object which is to have the
/// scale restored</param>
public void RestoreScale( GraphPane primaryPane )
{
if ( primaryPane != null )
{
//Go ahead and save the old zoomstates, which provides an "undo"-like capability
//ZoomState oldState = primaryPane.ZoomStack.Push( primaryPane, ZoomState.StateType.Zoom );
ZoomState oldState = new ZoomState( primaryPane, ZoomState.StateType.Zoom );
using ( Graphics g = this.CreateGraphics() )
{
if ( _isSynchronizeXAxes || _isSynchronizeYAxes )
{
foreach ( GraphPane pane in _masterPane._paneList )
{
pane.ZoomStack.Push( pane, ZoomState.StateType.Zoom );
ResetAutoScale( pane, g );
}
}
else
{
primaryPane.ZoomStack.Push( primaryPane, ZoomState.StateType.Zoom );
ResetAutoScale( primaryPane, g );
}
// Provide Callback to notify the user of zoom events
if ( this.ZoomEvent != null )
this.ZoomEvent( this, oldState, new ZoomState( primaryPane, ZoomState.StateType.Zoom ) );
//g.Dispose();
}
Refresh();
}
}
/// <summary>
/// Initialize the <see cref="Drawable"/> panel.
/// </summary>
public void Initialize()
{
this.SetStyle(
ControlStyles.UserPaint
| ControlStyles.AllPaintingInWmPaint
| ControlStyles.OptimizedDoubleBuffer
| ControlStyles.SupportsTransparentBackColor,
true);
this.BackColor = Color.Transparent;
_state = new ZoomState(Context.Editor);
this.MouseDown +=
(sender, e) =>
{
var p = e.Location;
if (e.Button == MouseButtons.Left)
{
this.Focus();
_state.LeftDown(p.X, p.Y);
}
if (e.Button == MouseButtons.Right)
{
this.Focus();
this.Cursor = Cursors.Hand;
_state.RightDown(p.X, p.Y);
}
};
this.MouseUp +=
(sender, e) =>
{
var p = e.Location;
if (e.Button == MouseButtons.Left)
{
this.Focus();
_state.LeftUp(p.X, p.Y);
}
if (e.Button == MouseButtons.Right)
{
this.Focus();
this.Cursor = Cursors.Default;
_state.RightUp(p.X, p.Y);
}
};
this.MouseMove +=
(sender, e) =>
{
var p = e.Location;
_state.Move(p.X, p.Y);
};
this.MouseWheel +=
(sender, e) =>
{
var p = e.Location;
if (Context == null || Context.Editor.Project == null)
return;
var container = Context.Editor.Project.CurrentContainer;
_state.Wheel(
p.X,
p.Y, e.Delta,
this.Width,
this.Height,
container.Template.Width,
container.Template.Height);
};
}
