protected override void OnPaint(PaintEventArgs e)
{
if (Map == null || Map.Image == null)
{
return;
}
// TODO: fix this
if (Map.Image.PixelFormat == PixelFormat.Undefined)
{
log.Error("Map image is broken - bug!");
return;
}
e.Graphics.DrawImageUnscaled(Map.Image, 0, 0);
//Trace.WriteLine("OnPaint " + onPaint++);
foreach (IMapTool tool in tools)
{
if (tool.IsActive)
{
tool.OnPaint(e);
}
}
SelectTool.OnPaint(e);
base.OnPaint(e);
}
public void DefaultMapControlTools()
{
InitializeControls();
// check for all default tools
IMapTool mapTool = mapControl.SelectTool;
Assert.IsNotNull(mapTool);
SelectTool selectTool = mapTool as SelectTool;
Assert.IsNotNull(selectTool);
mapTool = mapControl.MoveTool;
Assert.IsNotNull(mapTool);
MoveTool moveTool = mapTool as MoveTool;
Assert.IsNotNull(moveTool);
Assert.AreEqual(FallOffPolicyRule.None, moveTool.FallOffPolicy);
mapTool = mapControl.GetToolByName("CurvePoint");
Assert.IsNotNull(mapTool);
CurvePointTool curvePointTool = mapTool as CurvePointTool;
Assert.IsNotNull(curvePointTool);
}
/// <summary>
/// Applied before OnLeftClickDown runs.
/// </summary>
internal static bool Prefix(Vector3 cursor_pos, SelectTool __instance)
{
int cell = Grid.PosToCell(cursor_pos);
if (Grid.IsValidCell(cell))
{
var hits = __instance.hits;
int index = __instance.hitCycleCount;
if (GetAllSelectables(cell, cursor_pos, __instance.prevIntersectionGroup,
hits))
{
index = 0;
}
var target = GetIndexedSelectable(hits, ref index, __instance.layerMask,
__instance.selected);
__instance.hitCycleCount = index;
// Try Aze's override
var newTarget = __instance.GetObjectUnderCursor <KSelectable>(true);
if (newTarget != null)
{
target = newTarget;
}
__instance.Select(target);
}
__instance.selectedCell = cell;
return(false);
}
protected override void OnPaint(PaintEventArgs e)
{
//HACK: check if this works and then move this code/logic elsewhere
if (!DelayedEventHandlerController.FireEvents)
{
return;//stop painting..
}
if (Map == null || Map.Image == null)
{
return;
}
// TODO: fix this
if (Map.Image.PixelFormat == PixelFormat.Undefined)
{
Log.Error("Map image is broken - bug!");
return;
}
e.Graphics.DrawImageUnscaled(Map.Image, 0, 0);
foreach (var tool in tools.Where(tool => tool.IsActive))
{
tool.OnPaint(e);
}
SelectTool.OnPaint(e);
base.OnPaint(e);
}
private void RefreshSelectTool()
{
if (SelectTool != null)
{
SelectTool.RefreshFeatureInteractors();
}
}
/// <summary>
/// 实现圆选择查询
/// </summary>
/// <param name="control">地图视图控件</param>
/// <param name="dataType">选择数据时的数据类型过滤</param>
/// <param name="attctr">属性视图控件</param>
/// <param name="seltype">查询选择方式：圆查询 </param>
public CirSelectToolClass(MapGIS.GISControl.MapControl control, SelectDataType dataType, AttControl attctr, SelectType seltype)
: base()
{
this.mapCtrl = control;
this.dataType = dataType;
this.attCtrl = attctr;
this.selectType = seltype;
//查询选择项
SelectOption selOpt = new SelectOption();
selOpt.DataType = dataType; //选择数据时的类型过滤类型
selOpt.SelMode = SelectMode.Multiply; //选择模式
selOpt.UnMode = UnionMode.Xor; //结果数据合并模式
selOpt.LayerCtrl = SelectLayerControl.All; //选择数据时的图层过滤类型
//创建圆交互工具
selTool = new SelectTool(control, selectType, selOpt, SpaQueryMode.MBRIntersect, control.Transformation);
selTool.Selected += new SelectTool.SelectHandler(selTool_Selected);
this.Active += new ToolEventHandler(CirSelectToolClass_Active);
this.Unactive += new ToolEventHandler(CirSelectToolClass_Unactive);
this.Cancel += new ToolEventHandler(CirSelectToolClass_Cancel);
this.PreRefresh += new ToolEventHandler(CirSelectToolClass_PreRefresh);
this.PostRefresh += new ToolEventHandler(CirSelectToolClass_PostRefresh);
}
static Gtk.Toolbar CreateToolbar(CircuitEditor editor)
{
Gtk.Toolbar toolbar = new Gtk.Toolbar();
SelectTool selectTool = new SelectTool(editor, toolbar);
WireTool wireTool = new WireTool(editor, toolbar);
// FIXME: Make this be selected with a callback or something
//editor.CurrentTool = selectTool;
// FIXME: We don't want to new the components here!!
ComponentTool andTool = new ComponentTool(ComponentType.And, "And gate", editor, toolbar);
ComponentTool notTool = new ComponentTool(ComponentType.Not, "Not gate", editor, toolbar);
ComponentTool orTool = new ComponentTool(ComponentType.Or, "Or gate", editor, toolbar);
ToolButton xorTool = new ToolButton(
Util.Icon.XorGate(), "Xor Gate"
);
SeparatorToolItem sep = new SeparatorToolItem();
toolbar.Insert(selectTool, 0);
toolbar.Insert(wireTool, 1);
toolbar.Insert(sep, 2);
toolbar.Insert(andTool, 3);
toolbar.Insert(notTool, 4);
toolbar.Insert(orTool, 5);
toolbar.Insert(xorTool, 6);
return(toolbar);
}
private void SetNewTool(SelectTool tool)
{
currentTool = tool;
NewSelectTool?.Invoke(tool);
UpdateSelectedTransformTool();
}
public SelectionViewModel(ViewModelMain owner)
: base(owner)
{
DeselectCommand = new RelayCommand(Deselect, SelectionIsNotEmpty);
SelectAllCommand = new RelayCommand(SelectAll, CanSelectAll);
selectTool = new SelectTool(Owner.BitmapManager);
}
public void SelectAll(object parameter)
{
SelectTool select = new SelectTool();
var oldSelection = new List <Coordinates>(Owner.BitmapManager.ActiveDocument.ActiveSelection.SelectedPoints);
Owner.BitmapManager.ActiveDocument.ActiveSelection.SetSelection(select.GetAllSelection(), SelectionType.New);
SelectionHelpers.AddSelectionUndoStep(Owner.BitmapManager.ActiveDocument, oldSelection, SelectionType.New);
}
protected override void OnPrefabInit()
{
defaultLayerMask = (1 | LayerMask.GetMask("World", "Pickupable", "Place", "PlaceWithDepth", "BlockSelection", "Construction", "Selection"));
layerMask = defaultLayerMask;
selectMarker = Util.KInstantiateUI <SelectMarker>(EntityPrefabs.Instance.SelectMarker, GameScreenManager.Instance.worldSpaceCanvas, false);
selectMarker.gameObject.SetActive(false);
populateHitsList = true;
Instance = this;
}
//private Button btn;
private void Awake()
{
//PlayerTransform = GameObject.FindGameObjectWithTag("Player").transform;
//Debug.Log(PlayerTransform.name);
//realCamera = transform.GetChild(0).GetComponent<Camera>();
tool = GameObject.FindObjectOfType <SelectTool>();
//freeLook = GameObject.FindObjectOfType<CinemachineFreeLook>();
stateCamera = GameObject.FindObjectOfType <CinemachineStateDrivenCamera>();
}
public Instance3D(Model3D model)
{
m_SelectTool = new SelectTool();
m_Model = model;
UpdateTransform();
objectColor.Ambient = Color.Gray;
objectColor.Diffuse = Color.White;
fullBrightColor.Ambient = Color.White;
fullBrightColor.Diffuse = Color.White;
}
/// <summary>
/// Constructor. Requires a model filename to initialize properly.
/// </summary>
/// <param name="tfn"></param>
public Instance3D(TagFileName tfn)
{
m_SelectTool = new SelectTool();
SetModel(tfn);
UpdateTransform();
objectColor.Ambient = Color.Gray;
objectColor.Diffuse = Color.White;
fullBrightColor.Ambient = Color.White;
fullBrightColor.Diffuse = Color.White;
}
public void GetFeatureInteractorForLayerWithoutFeatureEditorShouldNotGiveErrorMessage_Tools8065()
{
var tool = new SelectTool();
var layer = new RegularGridCoverageLayer();
Assert.IsNotNull(layer.FeatureEditor);
// No message should be generated and null should be returned
TestHelper.AssertLogMessagesCount(() => Assert.IsNull(tool.GetFeatureInteractor(layer, null)), 0);
}
public Instance3D(PromDecal promdecal)
{
m_SelectTool = new SelectTool();
UpdateTransform();
this.decal = promdecal;
objectColor.Ambient = Color.Gray;
objectColor.Diffuse = Color.White;
fullBrightColor.Ambient = Color.White;
fullBrightColor.Diffuse = Color.White;
bDecalMode = true;
}
static Gtk.Toolbar CreateToolbar(CircuitEditor editor)
{
Gtk.Toolbar toolbar = new Gtk.Toolbar();
SelectTool selectTool = new SelectTool(editor);
WireTool wireTool = new WireTool(editor);
// FIXME: Make this be selected with a callback or something
//editor.CurrentTool = selectTool;
// FIXME: We want something better for this...
ComponentTool <AndGateInstance> andTool = new ComponentTool <AndGateInstance>(default, editor);
private void map_MapRendered(Graphics g)
{
// TODO: review, migrated from GeometryEditor
if (g == null)
{
return;
}
//UserLayer.Render(g, this.mapbox.Map);
// always draw trackers when they exist -> full redraw when trackers are deleted
SelectTool.Render(g, Map);
zoomHistoryTool.MapRendered(Map);
}
public void LoadResourceModel(string ResourcePath)
{
Stream st = Assembly.GetExecutingAssembly().GetManifestResourceStream(ResourcePath);
utilityModel = Mesh.FromStream(st, MeshFlags.Managed, MdxRender.Dev);
Matrix pitch = new Matrix();
Matrix yaw = new Matrix();
yaw.RotateZ((float)Math.PI);
pitch.RotateX((float)Math.PI / 2);
SelectTool.TransformMesh(utilityModel, Matrix.Multiply(pitch, yaw));
}
public void DeActiveSelectionShouldResetMultiSelectionMode()
{
MapControl mapControl = new MapControl();
SelectTool selectTool = mapControl.SelectTool;
selectTool.MultiSelectionMode = MultiSelectionMode.Lasso;
mapControl.ActivateTool(selectTool);
Assert.AreEqual(MultiSelectionMode.Lasso, selectTool.MultiSelectionMode);
mapControl.ActivateTool(mapControl.MoveTool);
Assert.AreEqual(MultiSelectionMode.Rectangle, selectTool.MultiSelectionMode);
}
/// <summary>
/// Initializes the device.
/// </summary>
public static void Initialize(Control renderTarget, Pool.Pool pool)
{
tagPool = pool;
if (d3dInitialized)
{
MdxRender.Device.Dispose();
}
RenderCore.renderTarget = renderTarget;
int adapter = Manager.Adapters.Default.Adapter;
caps = Manager.GetDeviceCaps(adapter, DeviceType);
pp.PresentationInterval = PresentInterval.Default;
pp.Windowed = true;// !MdxRender.FullScreen;
pp.SwapEffect = SwapEffect.Discard;
pp.EnableAutoDepthStencil = true;
pp.AutoDepthStencilFormat = GetDepthFormat(adapter);
//pp.MultiSample = GetMultiSampleType(adapter);
//pp.MultiSampleQuality = 0;
CreateFlags flags;
flags = CreateFlags.SoftwareVertexProcessing;
if (caps.DeviceCaps.SupportsHardwareTransformAndLight)
{
flags = CreateFlags.HardwareVertexProcessing;
}
// Disable built in events.
Device.IsUsingEventHandlers = false;
MdxRender.Device = new Device(adapter, DeviceType, renderTarget, flags, pp);
SetupDevice();
//MdxRender.Device.DeviceResizing += new System.ComponentModel.CancelEventHandler(device_DeviceResizing);
//MdxRender.Device.DeviceReset += new EventHandler(device_DeviceReset);
camera = new Camera.Camera();
MdxRender.FrameTimer = new FPSCounter(50);
SelectTool.InitializeHandleModel();
Billboard.LoadResources(0.5f, 0.5f);
fontFPS = new DXFont(MdxRender.Device, new Font("Arial", 12, FontStyle.Bold));
DebugFont = new Microsoft.DirectX.Direct3D.Font(MdxRender.Device, new Font("Arial", 12, FontStyle.Bold));
console = new DebugConsole.DebugConsole(MdxRender.Device);
d3dInitialized = true;
}
public Instance3D(BillboardModel bb)
{
int texture_index = MdxRender.SM.m_TextureManager.GetBillboardTextureIndex(bb);
m_SelectTool = new SelectTool();
m_Model = MdxRender.MM.ArrowModel;
m_BillboardMatrix = new Matrix();
billboard = new Billboard(0.5f, 0.5f, texture_index);
UpdateTransform();
objectColor.Ambient = Color.Gray;
objectColor.Diffuse = Color.White;
fullBrightColor.Ambient = Color.White;
fullBrightColor.Diffuse = Color.White;
bBillboardMode = true;
billboardCount++;
}
public void LoadArrow(string ResourcePath)
{
Stream st = Assembly.GetExecutingAssembly().GetManifestResourceStream(ResourcePath);
utilityModel = Mesh.FromStream(st, MeshFlags.Managed, MdxRender.Dev);
Matrix scale = new Matrix();
scale.Scale(0.2f, 0.2f, 0.2f);
Matrix pitch = new Matrix();
Matrix yaw = new Matrix();
yaw.RotateZ((float)Math.PI);
//pitch.RotateX((float)Math.PI/2);
SelectTool.TransformMesh(utilityModel, scale);
}
///// <summary>
///// Retrieves an appropriate multi sample format from the manager.
///// </summary>
//private static MultiSampleType GetMultiSampleType(int adapter)
//{
// if (Manager.CheckDeviceMultiSampleType(adapter, DeviceType, Format.X8R8G8B8, !FullScreen, MultiSampleType.FourSamples))
// return MultiSampleType.FourSamples;
// else if (Manager.CheckDeviceMultiSampleType(adapter, DeviceType, Format.X8R8G8B8, !FullScreen, MultiSampleType.TwoSamples))
// return MultiSampleType.TwoSamples;
// else if (Manager.CheckDeviceMultiSampleType(adapter, DeviceType, Format.X8R8G8B8, !FullScreen, MultiSampleType.NonMaskable))
// return MultiSampleType.NonMaskable;
// else
// return MultiSampleType.None;
//}
public static void PerformDeviceReset(int sizeX, int sizeY)
{
int res;
MdxRender.Device.CheckCooperativeLevel(out res);
//clean up unmanaged resources
fontFPS.OnLostDevice();
DebugFont.OnLostDevice();
tagPool.OnLostDevice();
console.OnLostDevice();
SelectTool.OnLostDevice();
Billboard.OnLostDevice();
foreach (SceneState scene in scenes)
{
scene.Instance.OnDeviceLost();
}
//reset the device with new viewport dimensions
pp.BackBufferWidth = sizeX;
pp.BackBufferHeight = sizeY;
//MdxRender.Device.Reset(pp);
//re-create unmanaged resources
fontFPS.OnResetDevice();
DebugFont.OnResetDevice();
tagPool.OnResetDevice();
console.OnResetDevice();
SelectTool.OnResetDevice();
Billboard.OnResetDevice();
foreach (SceneState scene in scenes)
{
scene.Instance.OnDeviceReset();
}
//re-init any state variables we need
SetupDevice();
UpdateViewTransform();
MdxRender.Device.Transform.World = Matrix.Identity;
MdxRender.Device.Transform.View = camera.GetViewMatrix();
}
public void ActualDeleteTriggersBeginEdit()
{
MapControl mapControl = new MapControl();
SelectTool selectTool = mapControl.SelectTool;
VectorLayer vectorLayer = new VectorLayer();
FeatureCollection layer2Data = new FeatureCollection();
vectorLayer.DataSource = layer2Data;
layer2Data.FeatureType = typeof(Feature);
layer2Data.Add(new Point(4, 5));
layer2Data.Add(new Point(0, 1));
mapControl.Map.Layers.Add(vectorLayer);
var featureMutator = mocks.StrictMock <IFeatureEditor>();
var editableObject = mocks.StrictMock <IEditableObject>();
featureMutator.Expect(fm => fm.EditableObject).Return(editableObject).Repeat.Any();
featureMutator.Expect(fm => fm.AllowDeletion()).Return(true).Repeat.Any();
featureMutator.Expect(fm => fm.Delete()).Repeat.Once();
editableObject.Expect(eo => eo.BeginEdit(null)).IgnoreArguments().Repeat.Once(); //expect BeginEdit!
editableObject.Expect(eo => eo.EndEdit()).IgnoreArguments().Repeat.Once();
mocks.ReplayAll();
selectTool.Select((IFeature)layer2Data.Features[0]);
selectTool.FeatureEditors.Clear();
selectTool.FeatureEditors.Add(featureMutator); //inject our own feature editor
var deleteTool = (DeleteTool)mapControl.GetToolByType(typeof(DeleteTool));
deleteTool.DeleteSelection();
mocks.VerifyAll();
}
public void CanDeleteWithoutEditableObject()
{
MapControl mapControl = new MapControl();
SelectTool selectTool = mapControl.SelectTool;
//mapControl.ActivateTool(selectTool);
VectorLayer vectorLayer = new VectorLayer();
FeatureCollection layer2Data = new FeatureCollection();
vectorLayer.DataSource = layer2Data;
layer2Data.FeatureType = typeof(Feature);
layer2Data.Add(new Point(4, 5));
layer2Data.Add(new Point(0, 1));
mapControl.Map.Layers.Add(vectorLayer);
selectTool.Select((IFeature)layer2Data.Features[0]);
DeleteTool deleteTool = (DeleteTool)mapControl.GetToolByType(typeof(DeleteTool));
deleteTool.DeleteSelection();
}
static Gtk.Toolbar CreateToolbar(CircuitEditor editor)
{
Gtk.Toolbar toolbar = new Gtk.Toolbar();
SelectTool selectTool = new SelectTool(editor, toolbar);
WireTool wireTool = new WireTool(editor, toolbar);
// FIXME: Make this be selected with a callback or something
//editor.CurrentTool = selectTool;
ComponentTool constantTool = new ComponentTool(ComponentType.Constant, "Constant", editor, toolbar);
ComponentTool bufferTool = new ComponentTool(ComponentType.Buffer, "Buffer gate", editor, toolbar);
ComponentTool notTool = new ComponentTool(ComponentType.Not, "Not gate", editor, toolbar);
ComponentTool andTool = new ComponentTool(ComponentType.And, "And gate", editor, toolbar);
ComponentTool orTool = new ComponentTool(ComponentType.Or, "Or gate", editor, toolbar);
ComponentTool xorTool = new ComponentTool(ComponentType.Xor, "Xor gate", editor, toolbar);
SeparatorToolItem sep = new SeparatorToolItem();
int index = 0;
toolbar.Insert(selectTool, index++);
toolbar.Insert(wireTool, index++);
toolbar.Insert(sep, index++);
toolbar.Insert(constantTool, index++);
toolbar.Insert(bufferTool, index++);
toolbar.Insert(notTool, index++);
toolbar.Insert(andTool, index++);
toolbar.Insert(orTool, index++);
toolbar.Insert(xorTool, index++);
return(toolbar);
}
private void OnNewSelectTool(SelectTool newTool)
{
UpdateVisibleTools();
}
public void SelectAll(object parameter)
{
SelectTool select = new SelectTool();
Owner.BitmapManager.ActiveDocument.ActiveSelection.SetSelection(select.GetAllSelection(), SelectionType.New);
}
/// <summary>
/// Initializes a new map
/// </summary>
public MapControl()
{
SetStyle(
ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw |
ControlStyles.UserPaint, true);
LostFocus += MapBox_LostFocus;
AllowDrop = true;
tools = new EventedList <IMapTool>();
tools.CollectionChanged += tools_CollectionChanged;
var northArrowTool = new NorthArrowTool(this);
northArrowTool.Anchor = AnchorStyles.Right | AnchorStyles.Top;
northArrowTool.Visible = false; // activate using commands
Tools.Add(northArrowTool);
var scaleBarTool = new ScaleBarTool(this);
scaleBarTool.Size = new Size(230, 50);
scaleBarTool.Anchor = AnchorStyles.Right | AnchorStyles.Bottom;
scaleBarTool.Visible = true;
Tools.Add(scaleBarTool);
legendTool = new LegendTool(this)
{
Anchor = AnchorStyles.Left | AnchorStyles.Top, Visible = false
};
Tools.Add(legendTool);
queryTool = new QueryTool(this);
Tools.Add(queryTool);
// add commonly used tools
zoomHistoryTool = new ZoomHistoryTool(this);
Tools.Add(zoomHistoryTool);
panZoomTool = new PanZoomTool(this);
Tools.Add(panZoomTool);
wheelZoomTool = new ZoomUsingMouseWheelTool(this);
wheelZoomTool.WheelZoomMagnitude = 0.8;
Tools.Add(wheelZoomTool);
rectangleZoomTool = new ZoomUsingRectangleTool(this);
Tools.Add(rectangleZoomTool);
fixedZoomInTool = new FixedZoomInTool(this);
Tools.Add(fixedZoomInTool);
fixedZoomOutTool = new FixedZoomOutTool(this);
Tools.Add(fixedZoomOutTool);
selectTool = new SelectTool {
IsActive = true
};
Tools.Add(selectTool);
moveTool = new MoveTool();
moveTool.Name = "Move selected vertices";
moveTool.FallOffPolicy = FallOffPolicyRule.None;
Tools.Add(moveTool);
linearMoveTool = new MoveTool();
linearMoveTool.Name = "Move selected vertices (linear)";
linearMoveTool.FallOffPolicy = FallOffPolicyRule.Linear;
Tools.Add(linearMoveTool);
deleteTool = new DeleteTool();
Tools.Add(deleteTool);
measureTool = new MeasureTool(this);
tools.Add(measureTool);
profileTool = new GridProfileTool(this);
profileTool.Name = "Make grid profile";
tools.Add(profileTool);
curvePointTool = new CurvePointTool();
Tools.Add(curvePointTool);
snapTool = new SnapTool();
Tools.Add(snapTool);
var toolTipTool = new ToolTipTool();
Tools.Add(toolTipTool);
MapTool fileHandlerTool = new FileDragHandlerTool();
Tools.Add(fileHandlerTool);
Tools.Add(new ExportMapToImageMapTool());
Width = 100;
Height = 100;
mapPropertyChangedEventHandler =
new SynchronizedDelayedEventHandler <PropertyChangedEventArgs>(map_PropertyChanged_Delayed)
{
FireLastEventOnly = true,
Delay2 = 300,
Filter = (sender, e) => sender is ILayer ||
sender is VectorStyle ||
sender is ITheme,
SynchronizeInvoke = this,
Enabled = false
};
mapCollectionChangedEventHandler =
new SynchronizedDelayedEventHandler <NotifyCollectionChangedEventArgs>(map_CollectionChanged_Delayed)
{
FireLastEventOnly = true,
Delay2 = 300,
Filter = (sender, e) => sender is Map ||
sender is ILayer,
SynchronizeInvoke = this,
Enabled = false
};
Map = new Map(ClientSize)
{
Zoom = 100
};
}
