mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-12-17 23:51:10 +00:00
979 lines
28 KiB
C#
979 lines
28 KiB
C#
|
|
#region ================== Copyright (c) 2007 Pascal vd Heiden
|
|
|
|
/*
|
|
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
|
|
* This program is released under GNU General Public License
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#endregion
|
|
|
|
#region ================== Namespaces
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using CodeImp.DoomBuilder.Config;
|
|
using CodeImp.DoomBuilder.Map;
|
|
using System.Globalization;
|
|
using CodeImp.DoomBuilder.Types;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.Controls
|
|
{
|
|
/// <summary>
|
|
/// Control to view and/or change custom UDMF fields.
|
|
/// </summary>
|
|
public partial class FieldsEditorControl : UserControl
|
|
{
|
|
#region ================== Constants
|
|
|
|
// Constants
|
|
private const string ADD_FIELD_TEXT = " (click to add custom field)";
|
|
private const string FIELD_PREFIX_SUGGESTION = "user_";
|
|
|
|
#endregion
|
|
|
|
#region ================== Variables
|
|
|
|
public delegate void SingleFieldNameEvent(string fieldname);
|
|
public delegate void DualFieldNameEvent(string oldname, string newname);
|
|
|
|
// Events
|
|
public event SingleFieldNameEvent OnFieldInserted;
|
|
public event DualFieldNameEvent OnFieldNameChanged;
|
|
public event SingleFieldNameEvent OnFieldValueChanged;
|
|
public event SingleFieldNameEvent OnFieldTypeChanged;
|
|
public event SingleFieldNameEvent OnFieldDeleted;
|
|
public event SingleFieldNameEvent OnFieldUndefined;
|
|
|
|
// Variables
|
|
private string elementname;
|
|
private string lasteditfieldname;
|
|
private bool autoinsertuserprefix;
|
|
private Dictionary<string, UniversalType> uifields;//mxd
|
|
private bool showfixedfields = true; //mxd
|
|
|
|
#endregion
|
|
|
|
#region ================== Properties
|
|
|
|
public bool AllowInsert { get { return fieldslist.AllowUserToAddRows; } set { fieldslist.AllowUserToAddRows = value; SetupNewRowStyle(); } }
|
|
public bool AutoInsertUserPrefix { get { return autoinsertuserprefix; } set { autoinsertuserprefix = value; } }
|
|
public int PropertyColumnWidth { get { return fieldname.Width; } set { fieldname.Width = value; UpdateValueColumn(); UpdateBrowseButton(); } }
|
|
public int TypeColumnWidth { get { return fieldtype.Width; } set { fieldtype.Width = value; UpdateValueColumn(); UpdateBrowseButton(); } }
|
|
public bool PropertyColumnVisible { get { return fieldname.Visible; } set { fieldname.Visible = value; UpdateValueColumn(); UpdateBrowseButton(); } }
|
|
public bool TypeColumnVisible { get { return fieldtype.Visible; } set { fieldtype.Visible = value; UpdateValueColumn(); UpdateBrowseButton(); } }
|
|
public bool ValueColumnVisible { get { return fieldvalue.Visible; } set { fieldvalue.Visible = value; UpdateValueColumn(); UpdateBrowseButton(); } }
|
|
public bool ShowFixedFields {get { return showfixedfields; } set { showfixedfields = value; UpdateFixedFieldsVisibility(); } } //mxd
|
|
|
|
#endregion
|
|
|
|
#region ================== Constructor
|
|
|
|
// Constructor
|
|
public FieldsEditorControl()
|
|
{
|
|
InitializeComponent();
|
|
autoinsertuserprefix = true;
|
|
enumscombo.Location = new Point(-1000, 1);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Setup / Apply
|
|
|
|
// This sets up the control
|
|
public void Setup(string elementname)
|
|
{
|
|
// Keep element name
|
|
this.elementname = elementname;
|
|
|
|
//mxd. Get proper UIFields
|
|
uifields = General.Map.FormatInterface.UIFields[General.Map.FormatInterface.GetElementType(elementname)];
|
|
|
|
// Make types list
|
|
fieldtype.Items.Clear();
|
|
fieldtype.Items.AddRange(General.Types.GetCustomUseAttributes());
|
|
}
|
|
|
|
// This applies last sort order
|
|
private void Sort()
|
|
{
|
|
// Sort
|
|
int sortcolumn = General.Settings.ReadSetting("customfieldssortcolumn", 0);
|
|
int sortorder = General.Settings.ReadSetting("customfieldssortorder", (int)ListSortDirection.Ascending);
|
|
|
|
switch(sortorder)
|
|
{
|
|
case (int)SortOrder.Ascending:
|
|
fieldslist.Sort(fieldslist.Columns[sortcolumn], ListSortDirection.Ascending);
|
|
break;
|
|
case (int)SortOrder.Descending:
|
|
fieldslist.Sort(fieldslist.Columns[sortcolumn], ListSortDirection.Descending);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// This adds a list of fixed fields (in undefined state)
|
|
public void ListFixedFields(List<UniversalFieldInfo> list)
|
|
{
|
|
// Add all fields
|
|
foreach(UniversalFieldInfo uf in list)
|
|
{
|
|
if(uifields.ContainsKey(uf.Name)) continue; //mxd
|
|
fieldslist.Rows.Add(new FieldsEditorRow(fieldslist, uf));
|
|
}
|
|
|
|
// Sort fields
|
|
Sort();
|
|
|
|
// Update new row
|
|
SetupNewRowStyle();
|
|
}
|
|
|
|
// Use this in case you don't want the fixed fields
|
|
public void ListNoFixedFields()
|
|
{
|
|
// Update new row
|
|
SetupNewRowStyle();
|
|
}
|
|
|
|
// Clear all fields
|
|
public void ClearFields()
|
|
{
|
|
// Trash rows
|
|
fieldslist.Rows.Clear();
|
|
|
|
// Update new row
|
|
SetupNewRowStyle();
|
|
}
|
|
|
|
// This sets up the fields and values from a UniFields object
|
|
// When first is true, the values are applied unconditionally
|
|
// When first is false, the values in the grid are erased when
|
|
// they differ from the given values (for multiselection)
|
|
public void SetValues(UniFields fromfields, bool first)
|
|
{
|
|
// Go for all the fields
|
|
foreach(KeyValuePair<string, UniValue> f in fromfields)
|
|
{
|
|
if(uifields.ContainsKey(f.Key)) continue; //mxd
|
|
|
|
// Go for all rows
|
|
bool foundrow = false;
|
|
bool skiprow = false; //mxd
|
|
foreach(DataGridViewRow row in fieldslist.Rows)
|
|
{
|
|
// Row is a field?
|
|
if(row is FieldsEditorRow)
|
|
{
|
|
FieldsEditorRow frow = row as FieldsEditorRow;
|
|
|
|
// Row name matches with field
|
|
if(frow.Name == f.Key)
|
|
{
|
|
//mxd. User vars are set separately
|
|
if(frow.RowType == FieldsEditorRowType.USERVAR)
|
|
{
|
|
skiprow = true;
|
|
break;
|
|
}
|
|
|
|
// First time?
|
|
if(first)
|
|
{
|
|
// Set type when row is not fixed
|
|
if(frow.RowType == FieldsEditorRowType.DYNAMIC) frow.ChangeType(f.Value.Type);
|
|
|
|
// Apply value of field to row
|
|
frow.Define(f.Value.Value);
|
|
}
|
|
else
|
|
{
|
|
// Check if the value is different
|
|
if(!frow.TypeHandler.GetValue().Equals(f.Value.Value))
|
|
{
|
|
// Clear the value in the row
|
|
frow.Define(f.Value.Value);
|
|
frow.Clear();
|
|
}
|
|
}
|
|
|
|
// Done
|
|
foundrow = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//mxd. User vars are set separately
|
|
if(skiprow) continue;
|
|
|
|
// Row not found?
|
|
if(!foundrow)
|
|
{
|
|
// Make new row
|
|
FieldsEditorRow frow = new FieldsEditorRow(fieldslist, f.Key, f.Value.Type, f.Value.Value, false);
|
|
fieldslist.Rows.Insert(fieldslist.Rows.Count - 1, frow);
|
|
|
|
// When not the first, clear the field because the others did not define this one
|
|
if(!first) frow.Clear();
|
|
}
|
|
}
|
|
|
|
// Now check for rows that the givens fields do NOT have
|
|
foreach(DataGridViewRow row in fieldslist.Rows)
|
|
{
|
|
// Row is a field?
|
|
if(row is FieldsEditorRow)
|
|
{
|
|
FieldsEditorRow frow = row as FieldsEditorRow;
|
|
|
|
// Is this row defined previously?
|
|
if(frow.IsDefined)
|
|
{
|
|
// Check if this row can not be found in the fields at all
|
|
if(!fromfields.ContainsKey(frow.Name))
|
|
{
|
|
// It is not defined in these fields, clear the value
|
|
frow.Clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort fields
|
|
Sort();
|
|
}
|
|
|
|
//mxd
|
|
public void SetUserVars(Dictionary<string, UniversalType> vars, UniFields fromfields, bool first)
|
|
{
|
|
foreach(KeyValuePair<string, UniversalType> group in vars)
|
|
{
|
|
// Go for all rows
|
|
bool foundrow = false;
|
|
TypeHandler vartype = General.Types.GetFieldHandler((int)group.Value, 0);
|
|
object value = fromfields.ContainsKey(group.Key) ? fromfields[group.Key].Value : vartype.GetDefaultValue();
|
|
|
|
foreach(DataGridViewRow row in fieldslist.Rows)
|
|
{
|
|
// Row is a field?
|
|
if(row is FieldsEditorRow)
|
|
{
|
|
FieldsEditorRow frow = row as FieldsEditorRow;
|
|
|
|
// Row name matches with user var?
|
|
if(frow.RowType == FieldsEditorRowType.USERVAR && frow.Name == group.Key)
|
|
{
|
|
// First time?
|
|
if(first)
|
|
{
|
|
frow.Define(value);
|
|
}
|
|
// Check if the value is different
|
|
else if(!frow.TypeHandler.GetValue().Equals(value))
|
|
{
|
|
// Clear the value in the row
|
|
frow.Define(value);
|
|
frow.Clear();
|
|
}
|
|
|
|
// Done
|
|
foundrow = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Row not found?
|
|
if(!foundrow)
|
|
{
|
|
// Make new row
|
|
object defaultvalue = vartype.GetDefaultValue();
|
|
FieldsEditorRow frow = new FieldsEditorRow(fieldslist, group.Key, (int)group.Value, defaultvalue, true);
|
|
if(!value.Equals(defaultvalue)) frow.Define(value);
|
|
fieldslist.Rows.Insert(fieldslist.Rows.Count - 1, frow);
|
|
}
|
|
}
|
|
|
|
// Now check for rows that the givens fields do NOT have
|
|
foreach(DataGridViewRow row in fieldslist.Rows)
|
|
{
|
|
// Row is a field?
|
|
if(row is FieldsEditorRow)
|
|
{
|
|
FieldsEditorRow frow = row as FieldsEditorRow;
|
|
|
|
// Don't undefine user var rows defined by other actor types
|
|
if(frow.RowType == FieldsEditorRowType.USERVAR || vars.ContainsKey(frow.Name)) continue;
|
|
|
|
// Is this row defined previously?
|
|
if(frow.IsDefined)
|
|
{
|
|
// Check if this row can not be found in the fields at all
|
|
if(!fromfields.ContainsKey(frow.Name))
|
|
{
|
|
// It is not defined in these fields, undefine the value
|
|
frow.Undefine();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort fields
|
|
Sort();
|
|
}
|
|
|
|
// This applies the current fields to a UniFields object
|
|
public void Apply(UniFields tofields)
|
|
{
|
|
tofields.BeforeFieldsChange();
|
|
|
|
// Go for all the fields
|
|
UniFields tempfields = new UniFields(tofields);
|
|
foreach(KeyValuePair<string, UniValue> f in tempfields)
|
|
{
|
|
if(uifields.ContainsKey(f.Key)) continue; //mxd
|
|
|
|
// Go for all rows
|
|
bool foundrow = false;
|
|
bool skiprow = false; //mxd
|
|
foreach(DataGridViewRow row in fieldslist.Rows)
|
|
{
|
|
// Row is a field and matches field name?
|
|
if((row is FieldsEditorRow) && (row.Cells[0].Value.ToString() == f.Key))
|
|
{
|
|
FieldsEditorRow frow = row as FieldsEditorRow;
|
|
|
|
//mxd. User vars are stored separately
|
|
if(frow.RowType == FieldsEditorRowType.USERVAR)
|
|
{
|
|
skiprow = true;
|
|
break;
|
|
}
|
|
|
|
// Field is defined?
|
|
if(frow.IsDefined)
|
|
{
|
|
foundrow = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//mxd. User vars are stored separately
|
|
if(skiprow) continue;
|
|
|
|
// No such row?
|
|
if(!foundrow)
|
|
{
|
|
// Remove the definition from the fields
|
|
tofields.Remove(f.Key);
|
|
}
|
|
}
|
|
|
|
// Go for all rows
|
|
foreach(DataGridViewRow row in fieldslist.Rows)
|
|
{
|
|
// Row is a field?
|
|
if(row is FieldsEditorRow)
|
|
{
|
|
FieldsEditorRow frow = row as FieldsEditorRow;
|
|
|
|
// Field is defined and not empty?
|
|
if(frow.RowType != FieldsEditorRowType.USERVAR && frow.IsDefined && !frow.IsEmpty)
|
|
{
|
|
// Apply field
|
|
object oldvalue = null;
|
|
if(tofields.ContainsKey(frow.Name)) oldvalue = tofields[frow.Name].Value;
|
|
tofields[frow.Name] = new UniValue(frow.TypeHandler.Index, frow.GetResult(oldvalue));
|
|
|
|
// Custom row?
|
|
if(frow.RowType == FieldsEditorRowType.DYNAMIC)
|
|
{
|
|
// Write type to map configuration
|
|
General.Map.Options.SetUniversalFieldType(elementname, frow.Name, frow.TypeHandler.Index);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
public void ApplyUserVars(Dictionary<string, UniversalType> vars, UniFields tofields)
|
|
{
|
|
// Apply user variables when target map element contains user var definition and the value is not default
|
|
foreach(DataGridViewRow row in fieldslist.Rows)
|
|
{
|
|
// Row is a field?
|
|
if(row is FieldsEditorRow)
|
|
{
|
|
FieldsEditorRow frow = row as FieldsEditorRow;
|
|
if(frow.RowType != FieldsEditorRowType.USERVAR || !vars.ContainsKey(frow.Name)) continue;
|
|
|
|
object oldvalue = (tofields.ContainsKey(frow.Name) ? tofields[frow.Name].Value : null);
|
|
object newvalue = frow.GetResult(oldvalue);
|
|
|
|
// Skip field when mixed values
|
|
if(newvalue == null) continue;
|
|
|
|
// Remove field
|
|
if(newvalue.Equals(frow.TypeHandler.GetDefaultValue()))
|
|
{
|
|
if(tofields.ContainsKey(frow.Name)) tofields.Remove(frow.Name);
|
|
}
|
|
// Add field
|
|
else if(!newvalue.Equals(oldvalue))
|
|
{
|
|
tofields[frow.Name] = new UniValue(frow.TypeHandler.Index, newvalue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Events
|
|
|
|
// Column header clicked
|
|
private void fieldslist_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
|
|
{
|
|
// Save sort order
|
|
if(fieldslist.SortedColumn != null)
|
|
{
|
|
int sortcolumn = fieldslist.SortedColumn.Index;
|
|
int sortorder = (int)fieldslist.SortOrder;
|
|
General.Settings.WriteSetting("customfieldssortcolumn", sortcolumn);
|
|
General.Settings.WriteSetting("customfieldssortorder", sortorder);
|
|
}
|
|
|
|
// Stop any cell editing
|
|
ApplyEnums(true);
|
|
fieldslist.EndEdit();
|
|
HideBrowseButton();
|
|
}
|
|
|
|
// Resized
|
|
private void FieldsEditorControl_Resize(object sender, EventArgs e)
|
|
{
|
|
// Rearrange controls
|
|
fieldslist.Size = this.ClientSize;
|
|
UpdateValueColumn();
|
|
UpdateBrowseButton();
|
|
}
|
|
|
|
// Layout change
|
|
private void FieldsEditorControl_Layout(object sender, LayoutEventArgs e)
|
|
{
|
|
FieldsEditorControl_Resize(sender, EventArgs.Empty);
|
|
}
|
|
|
|
// Cell clicked
|
|
private void fieldslist_CellClick(object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
ApplyEnums(true);
|
|
|
|
// Anything selected
|
|
if(fieldslist.SelectedCells.Count > 0)
|
|
{
|
|
if(e.RowIndex == fieldslist.NewRowIndex)
|
|
fieldslist.BeginEdit(false);
|
|
else if(e.ColumnIndex > 0)
|
|
fieldslist.BeginEdit(true);
|
|
}
|
|
}
|
|
|
|
// Cell doubleclicked
|
|
private void fieldslist_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
FieldsEditorRow frow = null;
|
|
|
|
// Anything selected
|
|
if(fieldslist.SelectedRows.Count > 0 && e.RowIndex > -1)
|
|
{
|
|
// Get the row
|
|
DataGridViewRow row = fieldslist.Rows[e.RowIndex];
|
|
if(row is FieldsEditorRow) frow = row as FieldsEditorRow;
|
|
|
|
// First column?
|
|
if(e.ColumnIndex == 0)
|
|
{
|
|
// Dynamic field?
|
|
if((frow != null) && frow.RowType == FieldsEditorRowType.DYNAMIC)
|
|
{
|
|
lasteditfieldname = frow.Name;
|
|
fieldslist.CurrentCell = fieldslist.SelectedRows[0].Cells[0];
|
|
fieldslist.CurrentCell.ReadOnly = false;
|
|
|
|
if((e.RowIndex == fieldslist.NewRowIndex) ||
|
|
frow.Name.StartsWith(FIELD_PREFIX_SUGGESTION, StringComparison.OrdinalIgnoreCase))
|
|
fieldslist.BeginEdit(false);
|
|
else
|
|
fieldslist.BeginEdit(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// User deletes a row
|
|
private void fieldslist_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e)
|
|
{
|
|
// Get the row
|
|
FieldsEditorRow row = e.Row as FieldsEditorRow;
|
|
if(row == null) return;
|
|
|
|
// Fixed/uservar field?
|
|
if(row.RowType == FieldsEditorRowType.FIXED || row.RowType == FieldsEditorRowType.USERVAR)
|
|
{
|
|
// Just undefine the field
|
|
row.Undefine();
|
|
e.Cancel = true;
|
|
|
|
if(OnFieldUndefined != null) OnFieldUndefined(row.Name);
|
|
}
|
|
else
|
|
{
|
|
if(OnFieldDeleted != null) OnFieldDeleted(row.Name);
|
|
}
|
|
}
|
|
|
|
// User selects a cell for editing
|
|
private void fieldslist_CellBeginEdit(object sender, DataGridViewCellCancelEventArgs e)
|
|
{
|
|
// Field name cell?
|
|
if(e.ColumnIndex == 0)
|
|
{
|
|
// New row index?
|
|
if(e.RowIndex == fieldslist.NewRowIndex)
|
|
{
|
|
// Remove all text
|
|
fieldslist.Rows[e.RowIndex].Cells[0].Style.ForeColor = SystemColors.WindowText;
|
|
fieldslist.Rows[e.RowIndex].Cells[0].Value = (autoinsertuserprefix ? FIELD_PREFIX_SUGGESTION : string.Empty);
|
|
}
|
|
}
|
|
// Value cell?
|
|
else if(e.ColumnIndex == 2)
|
|
{
|
|
// Get the row
|
|
DataGridViewRow row = fieldslist.Rows[e.RowIndex];
|
|
if(row is FieldsEditorRow)
|
|
{
|
|
// Get specializedrow
|
|
FieldsEditorRow frow = row as FieldsEditorRow;
|
|
|
|
// Enumerable?
|
|
if(frow.TypeHandler.IsEnumerable)
|
|
{
|
|
// Fill combo with enums
|
|
enumscombo.SelectedItem = null;
|
|
enumscombo.Text = "";
|
|
enumscombo.Items.Clear();
|
|
enumscombo.Items.AddRange(frow.TypeHandler.GetEnumList().ToArray());
|
|
enumscombo.Tag = frow;
|
|
|
|
// Lock combo to enums?
|
|
if(frow.TypeHandler.IsLimitedToEnums)
|
|
enumscombo.DropDownStyle = ComboBoxStyle.DropDownList;
|
|
else
|
|
enumscombo.DropDownStyle = ComboBoxStyle.DropDown;
|
|
|
|
// Position combobox
|
|
Rectangle cellrect = fieldslist.GetCellDisplayRectangle(2, row.Index, false);
|
|
enumscombo.Location = new Point(cellrect.Left, cellrect.Top);
|
|
enumscombo.Width = cellrect.Width;
|
|
int internalheight = cellrect.Height - (enumscombo.Height - enumscombo.ClientRectangle.Height) - 6;
|
|
General.SendMessage(enumscombo.Handle, General.CB_SETITEMHEIGHT, -1, internalheight);
|
|
|
|
// Select the value of this field (for DropDownList style combo)
|
|
foreach(EnumItem i in enumscombo.Items)
|
|
{
|
|
// Matches?
|
|
if(string.Compare(i.Title, frow.TypeHandler.GetStringValue(), StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
// Select this item
|
|
enumscombo.SelectedItem = i;
|
|
break; //mxd
|
|
}
|
|
}
|
|
|
|
// Put the display text in the text (for DropDown style combo)
|
|
enumscombo.Text = frow.TypeHandler.GetStringValue();
|
|
|
|
// Show combo
|
|
enumscombo.Show();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Done editing cell contents
|
|
private void fieldslist_CellEndEdit(object sender, DataGridViewCellEventArgs e)
|
|
{
|
|
FieldsEditorRow frow = null;
|
|
|
|
// Get the row
|
|
DataGridViewRow row = fieldslist.Rows[e.RowIndex];
|
|
if(row is FieldsEditorRow) frow = row as FieldsEditorRow;
|
|
|
|
// Renaming a field?
|
|
if(e.ColumnIndex == 0)
|
|
{
|
|
// Row is a new row?
|
|
if(frow == null)
|
|
{
|
|
// Name given?
|
|
if((row.Cells[0].Value != null) && (row.Cells[0].Value.ToString() != FIELD_PREFIX_SUGGESTION))
|
|
{
|
|
// Make a valid UDMF field name
|
|
string validname = UniValue.ValidateName(row.Cells[0].Value.ToString());
|
|
if(validname.Length > 0)
|
|
{
|
|
if(uifields.ContainsKey(validname)) //mxd
|
|
{
|
|
MessageBox.Show("Please set this field's value via user interface.");
|
|
}
|
|
else
|
|
{
|
|
// Check if no other row already has this name
|
|
foreach(DataGridViewRow r in fieldslist.Rows)
|
|
{
|
|
// Name matches and not the same row?
|
|
if((r.Index != row.Index) && (r.Cells.Count > 0) && (r.Cells[0].Value != null) &&
|
|
(r.Cells[0].Value.ToString().ToLowerInvariant() == validname))
|
|
{
|
|
// Cannot have two rows with same name
|
|
validname = "";
|
|
General.ShowWarningMessage("Fields must have unique names!", MessageBoxButtons.OK);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Still valid?
|
|
if(validname.Length > 0)
|
|
{
|
|
// Try to find the type in the map options
|
|
int type = General.Map.Options.GetUniversalFieldType(elementname, validname, 0);
|
|
|
|
// Make new row
|
|
frow = new FieldsEditorRow(fieldslist, validname, type, null, false);
|
|
frow.Visible = false;
|
|
fieldslist.Rows.Insert(e.RowIndex + 1, frow);
|
|
|
|
if(OnFieldInserted != null) OnFieldInserted(validname);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mark the row for delete
|
|
row.ReadOnly = true;
|
|
deleterowstimer.Start();
|
|
}
|
|
else
|
|
{
|
|
// Name given?
|
|
if(row.Cells[0].Value != null)
|
|
{
|
|
// Make a valid UDMF field name
|
|
string validname = UniValue.ValidateName(row.Cells[0].Value.ToString());
|
|
if(validname.Length > 0 && !uifields.ContainsKey(validname)) //mxd
|
|
{
|
|
// Check if no other row already has this name
|
|
foreach(DataGridViewRow r in fieldslist.Rows)
|
|
{
|
|
// Name matches and not the same row?
|
|
if((r.Index != row.Index) && (r.Cells.Count > 0) && (r.Cells[0].Value != null) &&
|
|
(r.Cells[0].Value.ToString().ToLowerInvariant() == validname))
|
|
{
|
|
// Cannot have two rows with same name
|
|
validname = "";
|
|
row.Cells[0].Value = lasteditfieldname;
|
|
General.ShowWarningMessage("Fields must have unique names!", MessageBoxButtons.OK);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Still valid?
|
|
if(validname.Length > 0)
|
|
{
|
|
// Try to find the type in the map options
|
|
int type = General.Map.Options.GetUniversalFieldType(elementname, validname, -1);
|
|
|
|
// Rename row and change type
|
|
row.Cells[0].Value = validname;
|
|
if(type != -1) frow.ChangeType(type);
|
|
|
|
if(OnFieldNameChanged != null) OnFieldNameChanged(lasteditfieldname, validname);
|
|
if(OnFieldTypeChanged != null) OnFieldTypeChanged(validname);
|
|
}
|
|
else
|
|
{
|
|
// Keep old name
|
|
row.Cells[0].Value = lasteditfieldname;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Keep old name
|
|
row.Cells[0].Value = lasteditfieldname;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Keep old name
|
|
row.Cells[0].Value = lasteditfieldname;
|
|
}
|
|
}
|
|
}
|
|
// Changing field type?
|
|
if((e.ColumnIndex == 1) && (frow != null))
|
|
{
|
|
if(OnFieldTypeChanged != null) OnFieldTypeChanged(frow.Name);
|
|
}
|
|
// Changing field value?
|
|
if((e.ColumnIndex == 2) && (frow != null))
|
|
{
|
|
// Apply changes
|
|
ApplyValue(frow, row.Cells[2].Value);
|
|
}
|
|
|
|
// Updated
|
|
if(frow != null) frow.CellChanged();
|
|
|
|
// Update button
|
|
UpdateBrowseButton();
|
|
}
|
|
|
|
// Time to delete rows
|
|
private void deleterowstimer_Tick(object sender, EventArgs e)
|
|
{
|
|
// Stop timer
|
|
deleterowstimer.Stop();
|
|
|
|
// Delete all rows that must be deleted
|
|
for(int i = fieldslist.Rows.Count - 1; i >= 0; i--)
|
|
{
|
|
if(fieldslist.Rows[i].ReadOnly)
|
|
{
|
|
try { fieldslist.Rows.RemoveAt(i); } catch { }
|
|
}
|
|
else
|
|
{
|
|
//mxd. Preserve fixed fields visibility setting
|
|
FieldsEditorRow frow = (fieldslist.Rows[i] as FieldsEditorRow);
|
|
if(frow != null && frow.RowType == FieldsEditorRowType.FIXED) frow.Visible = showfixedfields;
|
|
else fieldslist.Rows[i].Visible = true;
|
|
}
|
|
}
|
|
|
|
// Update new row
|
|
SetupNewRowStyle();
|
|
|
|
// Update button
|
|
UpdateBrowseButton();
|
|
}
|
|
|
|
// Selection changes
|
|
private void fieldslist_SelectionChanged(object sender, EventArgs e)
|
|
{
|
|
browsebutton.Visible = false;
|
|
ApplyEnums(true);
|
|
|
|
// Update button
|
|
UpdateBrowseButton();
|
|
}
|
|
|
|
// Browse clicked
|
|
private void browsebutton_Click(object sender, EventArgs e)
|
|
{
|
|
// Any row selected?
|
|
if(fieldslist.SelectedRows.Count > 0)
|
|
{
|
|
// Get selected row
|
|
DataGridViewRow row = fieldslist.SelectedRows[0];
|
|
if(row is FieldsEditorRow)
|
|
{
|
|
// Browse
|
|
(row as FieldsEditorRow).Browse(this.ParentForm);
|
|
fieldslist.Focus();
|
|
}
|
|
}
|
|
}
|
|
|
|
// This handles field data errors
|
|
private void fieldslist_DataError(object sender, DataGridViewDataErrorEventArgs e)
|
|
{
|
|
// Ignore this, because we want to display values
|
|
// in the type column that are not in their combobox
|
|
e.ThrowException = false;
|
|
}
|
|
|
|
// Validate value in enums combobox
|
|
private void enumscombo_Validating(object sender, CancelEventArgs e)
|
|
{
|
|
ApplyEnums(false);
|
|
}
|
|
|
|
// Scrolling
|
|
private void fieldslist_Scroll(object sender, ScrollEventArgs e)
|
|
{
|
|
// Stop any cell editing
|
|
ApplyEnums(true);
|
|
fieldslist.EndEdit();
|
|
HideBrowseButton();
|
|
}
|
|
|
|
// Mouse up event
|
|
private void fieldslist_MouseUp(object sender, MouseEventArgs e)
|
|
{
|
|
// Focus to enums combobox when visible
|
|
if(enumscombo.Visible)
|
|
{
|
|
enumscombo.Focus();
|
|
enumscombo.SelectAll();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Private Methods
|
|
|
|
// This applies a value to a row
|
|
private void ApplyValue(FieldsEditorRow frow, object value)
|
|
{
|
|
// Defined?
|
|
if((value != null) && (frow.RowType == FieldsEditorRowType.DYNAMIC || frow.RowType == FieldsEditorRowType.USERVAR
|
|
|| !frow.Info.Default.Equals(value)))
|
|
{
|
|
frow.Define(value);
|
|
}
|
|
else if(frow.RowType == FieldsEditorRowType.FIXED)
|
|
{
|
|
frow.Undefine();
|
|
}
|
|
|
|
if(OnFieldValueChanged != null) OnFieldValueChanged(frow.Name);
|
|
}
|
|
|
|
// This applies the contents of the enums combobox and hides (if opened)
|
|
private void ApplyEnums(bool hide)
|
|
{
|
|
// Enums combobox shown?
|
|
if((enumscombo.Visible) && (enumscombo.Tag is FieldsEditorRow))
|
|
{
|
|
// Get the row
|
|
FieldsEditorRow frow = (enumscombo.Tag as FieldsEditorRow);
|
|
|
|
// Take the selected value and apply it
|
|
ApplyValue(frow, enumscombo.Text);
|
|
|
|
// Updated
|
|
frow.CellChanged();
|
|
}
|
|
|
|
if(hide)
|
|
{
|
|
// Hide combobox
|
|
enumscombo.Tag = null;
|
|
enumscombo.Visible = false;
|
|
enumscombo.Items.Clear();
|
|
}
|
|
}
|
|
|
|
// This sets up the new row
|
|
private void SetupNewRowStyle()
|
|
{
|
|
if(fieldslist.AllowUserToAddRows)
|
|
{
|
|
// Show text for new row
|
|
fieldslist.Rows[fieldslist.NewRowIndex].Cells[0].Value = ADD_FIELD_TEXT;
|
|
fieldslist.Rows[fieldslist.NewRowIndex].Cells[0].Style.ForeColor = SystemColors.GrayText;
|
|
fieldslist.Rows[fieldslist.NewRowIndex].Cells[0].ReadOnly = false;
|
|
|
|
// Make sure user can only enter property name in a new row
|
|
fieldslist.Rows[fieldslist.NewRowIndex].Cells[1].ReadOnly = true;
|
|
fieldslist.Rows[fieldslist.NewRowIndex].Cells[2].ReadOnly = true;
|
|
}
|
|
}
|
|
|
|
// This hides the browse button
|
|
private void HideBrowseButton()
|
|
{
|
|
browsebutton.Visible = false;
|
|
}
|
|
|
|
// This updates the Value column width
|
|
private void UpdateValueColumn()
|
|
{
|
|
int fieldnamewidth = fieldname.Visible ? fieldname.Width : 0;
|
|
int fieldtypewidth = fieldtype.Visible ? fieldtype.Width : 0;
|
|
fieldvalue.Width = fieldslist.ClientRectangle.Width - fieldnamewidth - fieldtypewidth - SystemInformation.VerticalScrollBarWidth - 10;
|
|
}
|
|
|
|
// This updates the button
|
|
private void UpdateBrowseButton()
|
|
{
|
|
FieldsEditorRow frow = null;
|
|
|
|
// Any row selected?
|
|
if(fieldslist.SelectedRows.Count > 0)
|
|
{
|
|
// Get selected row
|
|
DataGridViewRow row = fieldslist.SelectedRows[0];
|
|
if(row is FieldsEditorRow) frow = row as FieldsEditorRow;
|
|
|
|
// Not the new row and FieldsEditorRow available?
|
|
if((row.Index < fieldslist.NewRowIndex) && (frow != null))
|
|
{
|
|
// Browse button available for this type?
|
|
if(frow.TypeHandler.IsBrowseable && !frow.TypeHandler.IsEnumerable)
|
|
{
|
|
Rectangle cellrect = fieldslist.GetCellDisplayRectangle(2, row.Index, false);
|
|
|
|
// Show button
|
|
enumscombo.Visible = false;
|
|
browsebutton.Image = frow.TypeHandler.BrowseImage;
|
|
browsebutton.Location = new Point(cellrect.Right - browsebutton.Width, cellrect.Top);
|
|
browsebutton.Height = cellrect.Height;
|
|
browsebutton.Visible = true;
|
|
}
|
|
else
|
|
{
|
|
HideBrowseButton();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HideBrowseButton();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HideBrowseButton();
|
|
}
|
|
}
|
|
|
|
//mxd
|
|
private void UpdateFixedFieldsVisibility()
|
|
{
|
|
foreach(var row in fieldslist.Rows)
|
|
{
|
|
FieldsEditorRow frow = (row as FieldsEditorRow);
|
|
if(frow != null && frow.RowType == FieldsEditorRowType.FIXED) frow.Visible = showfixedfields;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|