1078 lines
40 KiB
C#
1078 lines
40 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using JWH.DATA;
|
|
using Telerik.WinControls;
|
|
using Telerik.WinControls.Data;
|
|
using Telerik.WinControls.Export;
|
|
using Telerik.WinControls.UI;
|
|
using static JWH.DATA.CustomerAttributes;
|
|
|
|
namespace JWH.CONTROL
|
|
{
|
|
|
|
public class GridViewEx : RadGridView
|
|
{
|
|
|
|
public static CultureInfo CultureInfo { get; set; } = CultureInfo.CurrentCulture;
|
|
|
|
public delegate void ContextMenuHandler(object sender, params object[] args);
|
|
|
|
[Flags]
|
|
public enum eDateTimeGroupKey
|
|
{
|
|
None = 0b00000000,
|
|
Year = 0b00000001,
|
|
Month = 0b00000010,
|
|
Day = 0b00000100,
|
|
Hour = 0b00010000,
|
|
Minute =0b00100000,
|
|
Second =0b01000000,
|
|
Date = 0b00000111,
|
|
}
|
|
|
|
#region [ Properties ] ================================================
|
|
|
|
public override string ThemeClassName { get { return typeof(RadGridView).FullName; } }
|
|
|
|
[Browsable(false), ReadOnly(true)]
|
|
public Dictionary<string, List<ComboBoxItem>> ComboBoxCollection { get; } = new Dictionary<string, List<ComboBoxItem>>();
|
|
|
|
[DefaultValue(true)]
|
|
public bool ShowRowNumber { get; set; } = true;
|
|
|
|
[Browsable(false), ReadOnly(true)]
|
|
public List<object> DataBindingItems { get; set; } = new List<object>();
|
|
|
|
[Browsable(false), DefaultValue(null)]
|
|
public new RadContextMenu ContextMenu { get; set; } = null;
|
|
|
|
[Browsable(false), DefaultValue(false)]
|
|
public bool IsSetColumn { get; set; } = false;
|
|
|
|
public Keys ColumnResizeKey { get; set; } = Keys.F6;
|
|
|
|
/// <summary>
|
|
/// HeaderText 값을 자동으로 생성하는 경우에 ToTitleCase로 변환한다. (AddColumn 메서드에서 HeaderText가 정의되지 않은 경우)
|
|
/// </summary>
|
|
[Browsable(true), DefaultValue(true)]
|
|
public bool HeaderTextToTitleCase { get; set; } = true;
|
|
|
|
[Browsable(false), DefaultValue(eDateTimeGroupKey.Date)]
|
|
public eDateTimeGroupKey DateTimeGroupKey { get; set; } = eDateTimeGroupKey.Date;
|
|
|
|
#endregion
|
|
|
|
#region [ Constructor ] ===============================================
|
|
|
|
public GridViewEx() : base()
|
|
{
|
|
if (LicenseManager.UsageMode == LicenseUsageMode.Designtime) return;
|
|
|
|
this.SetLayout();
|
|
this.SetEventHandler();
|
|
if (Telerik.Data.Expressions.ExpressionContext.Context.GetType() != typeof(CustomerExpressionContext))
|
|
Telerik.Data.Expressions.ExpressionContext.Context = new CustomerExpressionContext();
|
|
}
|
|
|
|
protected void SetLayout()
|
|
{
|
|
this.Font = new Font(new FontFamily("돋움체"), 9.0F);
|
|
|
|
this.AllowAddNewRow = false;
|
|
this.AddNewRowPosition = SystemRowPosition.Top;
|
|
this.NewRowEnterKeyMode = RadGridViewNewRowEnterKeyMode.EnterMovesToLastAddedRow;
|
|
|
|
this.SelectionMode = GridViewSelectionMode.FullRowSelect;
|
|
|
|
this.AutoSizeRows = false;
|
|
this.TableElement.RowHeight = 20;
|
|
|
|
this.AllowAutoSizeColumns = false;
|
|
this.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.None;
|
|
|
|
this.EnableFiltering = true;
|
|
this.ShowFilteringRow = false;
|
|
this.ShowHeaderCellButtons = true;
|
|
this.ShowNoDataText = true;
|
|
this.ShowRowErrors = true;
|
|
this.ShowGroupedColumns = true;
|
|
this.ShowGroupPanelScrollbars = true;
|
|
|
|
this.MasterTemplate.GroupPredicate = this.PerformGrouping;
|
|
|
|
if (this.ContextMenu == null) this.ContextMenu = new RadContextMenu();
|
|
this.AddContextMenu("Column Chooser", this.ShowColumnChooser);
|
|
this.AddContextMenu("Copy Cell Text", this.Clipboard_CurrentCellValue, true);
|
|
this.AddContextMenu("Copy Row Text", this.Clipboard_CurrentRowValue);
|
|
this.AddContextMenu("Export Excel", this.ExportExcelDialog, true);
|
|
}
|
|
|
|
protected void SetEventHandler()
|
|
{
|
|
this.MouseDown += this.GridViewEx_MouseDown;
|
|
|
|
this.DataBindingComplete += GridViewEx_DataBindingComplete;
|
|
this.ContextMenuOpening += GridViewEx_ContextMenuOpening;
|
|
this.GroupSummaryEvaluate += GridViewEx_GroupSummaryEvaluate;
|
|
this.ValueChanged += GridViewEx_ValueChanged;
|
|
this.CopyingCellClipboardContent += GridViewEx_CopyingCellClipboardContent;
|
|
this.PastingCellClipboardContent += GridViewEx_PastingCellClipboardContent;
|
|
|
|
this.RowsChanging += GridViewEx_RowChanging;
|
|
this.Rows.CollectionChanged += GridViewEx_RowsCollectionChanged;
|
|
|
|
this.CellEditorInitialized += GridViewEx_CellEditorInitialized;
|
|
this.CellFormatting += GridViewEx_CellFormatting;
|
|
this.CellBeginEdit += GridViewEx_CellBeginEdit;
|
|
this.CellEndEdit += GridViewEx_CellEndEdit;
|
|
this.ViewCellFormatting += GridViewEx_ViewCellFormatting;
|
|
}
|
|
|
|
protected override void OnLayout(LayoutEventArgs e)
|
|
{
|
|
base.OnLayout(e);
|
|
}
|
|
|
|
protected override void OnLoad(Size desiredSize)
|
|
{
|
|
base.OnLoad(desiredSize);
|
|
|
|
this.BestFitColumns(BestFitColumnMode.HeaderCells);
|
|
}
|
|
|
|
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
|
|
{
|
|
try
|
|
{
|
|
if (keyData == this.ColumnResizeKey) this.BestFitColumns();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
XLogger.Instance.Fatal(ex);
|
|
}
|
|
return base.ProcessCmdKey(ref msg, keyData);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ Events ] ====================================================
|
|
|
|
private void GridViewEx_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
switch (e.Button)
|
|
{
|
|
case MouseButtons.XButton1:
|
|
// PageDown
|
|
base.OnKeyDown(new KeyEventArgs(Keys.PageDown));
|
|
break;
|
|
case MouseButtons.XButton2:
|
|
// PageUp
|
|
base.OnKeyDown(new KeyEventArgs(Keys.PageUp));
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void GridViewEx_DataBindingComplete(object sender, GridViewBindingCompleteEventArgs e)
|
|
{
|
|
this.SuspendLayout();
|
|
ICollection<object> collection = this.DataSource as ICollection<object>;
|
|
if (collection == null || collection.Count < 1) this.BestFitColumns(BestFitColumnMode.HeaderCells);
|
|
else if (collection.Count < 500) this.BestFitColumns(BestFitColumnMode.AllCells);
|
|
else this.BestFitColumns(BestFitColumnMode.DisplayedCells);
|
|
|
|
// Resizing
|
|
foreach (GridViewDataColumn column in this.Columns)
|
|
if (column.Width > this.Width * 0.5F) column.Width = (int)(this.Width * 0.5F);
|
|
|
|
if (this.ShowRowNumber)
|
|
this.TableElement.RowHeaderColumnWidth = (int)this.CreateGraphics().MeasureString(this.Rows.Count.ToString(), this.Font).Width + 16;
|
|
this.ResumeLayout();
|
|
}
|
|
|
|
private void GridViewEx_ContextMenuOpening(object sender, ContextMenuOpeningEventArgs e)
|
|
{
|
|
if (this.ContextMenu != null)
|
|
e.ContextMenu = this.ContextMenu.DropDown;
|
|
}
|
|
|
|
private void GridViewEx_GroupSummaryEvaluate(object sender, GroupSummaryEvaluationEventArgs e)
|
|
{
|
|
if (e.Context.GetType() != typeof(GridViewSummaryRowInfo))
|
|
{
|
|
GridViewGroupRowInfo row = e.Parent as GridViewGroupRowInfo;
|
|
e.FormatString = $"[{row?.Index}] {e.SummaryItem.Name}: {e.Value} Count={e.Group.ItemCount}";
|
|
}
|
|
}
|
|
|
|
private void GridViewEx_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
}
|
|
|
|
private void GridViewEx_CopyingCellClipboardContent(object sender, GridViewCellValueEventArgs e)
|
|
{
|
|
}
|
|
|
|
private void GridViewEx_PastingCellClipboardContent(object sender, GridViewCellValueEventArgs e)
|
|
{
|
|
DataTableBase data = this.Rows[e.RowIndex].DataBoundItem as DataTableBase;
|
|
if (data == null) return;
|
|
}
|
|
|
|
private void GridViewEx_RowChanging(object sender, GridViewCollectionChangingEventArgs e)
|
|
{
|
|
switch (e.Action)
|
|
{
|
|
case NotifyCollectionChangedAction.Add:
|
|
break;
|
|
case NotifyCollectionChangedAction.Remove:
|
|
break;
|
|
case NotifyCollectionChangedAction.Replace:
|
|
case NotifyCollectionChangedAction.Move:
|
|
case NotifyCollectionChangedAction.Reset:
|
|
case NotifyCollectionChangedAction.Batch:
|
|
break;
|
|
case NotifyCollectionChangedAction.ItemChanging:
|
|
case NotifyCollectionChangedAction.ItemChanged:
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void GridViewEx_RowsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
}
|
|
|
|
private void GridViewEx_CellEditorInitialized(object sender, GridViewCellEventArgs e)
|
|
{
|
|
}
|
|
|
|
private void GridViewEx_CellFormatting(object sender, Telerik.WinControls.UI.CellFormattingEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
GridViewDataColumn column = e.CellElement.ColumnInfo as GridViewDataColumn;
|
|
if (column.GetType() == typeof(GridViewDateTimeColumn))
|
|
{
|
|
var value = e.CellElement.RowInfo.Cells[column.Name].Value;
|
|
DateTime dtValue = DateTime.MinValue;
|
|
if (value != null) dtValue = Convert.ToDateTime(value);
|
|
|
|
if (dtValue == DateTime.MinValue) e.CellElement.Text = "";
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
XLogger.Instance.Fatal(ex);
|
|
}
|
|
}
|
|
|
|
private void GridViewEx_CellBeginEdit(object sender, GridViewCellCancelEventArgs e)
|
|
{
|
|
DataTableBase data = e.Row.DataBoundItem as DataTableBase;
|
|
if (data == null) return;
|
|
|
|
// Check PrimaryKey Property
|
|
PropertyInfo prop = null;
|
|
PrimaryKeyAttribute attrPK = null;
|
|
prop = data.GetType().GetProperty(e.Column.FieldName);
|
|
if (prop != null) attrPK = prop.GetCustomAttribute(typeof(PrimaryKeyAttribute)) as PrimaryKeyAttribute;
|
|
if (attrPK != null && attrPK.PrimaryKey)
|
|
{
|
|
e.Cancel = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void GridViewEx_CellEndEdit(object sender, GridViewCellEventArgs e)
|
|
{
|
|
}
|
|
|
|
private void GridViewEx_ViewCellFormatting(object sender, Telerik.WinControls.UI.CellFormattingEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.ShowRowNumber == false) return;
|
|
|
|
if (e.CellElement is GridRowHeaderCellElement && e.Row is GridViewDataRowInfo)
|
|
{
|
|
e.CellElement.Text = (e.CellElement.RowIndex + 1).ToString();
|
|
e.CellElement.TextImageRelation = TextImageRelation.ImageBeforeText;
|
|
}
|
|
else
|
|
{
|
|
e.CellElement.ResetValue(LightVisualElement.TextImageRelationProperty, ValueResetFlags.Local);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
XLogger.Instance.Fatal(ex);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ Methods ] ===================================================
|
|
|
|
#region [ AutoBinding ] -----------------------------------------------
|
|
|
|
/// <summary>
|
|
/// Add Column
|
|
/// </summary>
|
|
/// <param name="fieldName"></param>
|
|
/// <param name="headerText"></param>
|
|
/// <param name="readOnly"></param>
|
|
/// <returns></returns>
|
|
public GridViewDataColumn AddColumn(string fieldName, string headerText = "", bool readOnly = true, string formatString = "")
|
|
{
|
|
|
|
this.IsSetColumn = false;
|
|
if (string.IsNullOrEmpty(headerText))
|
|
{
|
|
headerText = fieldName.Replace('_', ' ');
|
|
if (HeaderTextToTitleCase)
|
|
{
|
|
TextInfo textIF = CultureInfo.CurrentCulture.TextInfo;
|
|
headerText = textIF.ToTitleCase(headerText.ToLower());
|
|
}
|
|
}
|
|
|
|
GridViewDataColumn column = null;
|
|
{
|
|
GridViewTextBoxColumn temp = new GridViewTextBoxColumn();
|
|
temp.FieldName = fieldName;
|
|
temp.HeaderText = headerText;
|
|
temp.ReadOnly = readOnly;
|
|
temp.FormatString = formatString;
|
|
column = temp;
|
|
}
|
|
|
|
this.Columns.Add(column);
|
|
|
|
return column;
|
|
}
|
|
|
|
public GridViewDataColumn AddColumn(Type type, string fieldName, string headerText = "", bool readOnly = true, string formatString = "")
|
|
{
|
|
GridViewDataColumn column = Activator.CreateInstance(type) as GridViewDataColumn;
|
|
if (column == null) return null;
|
|
|
|
this.IsSetColumn = false;
|
|
if (string.IsNullOrEmpty(headerText))
|
|
{
|
|
TextInfo textIF = CultureInfo.TextInfo;
|
|
headerText = textIF.ToTitleCase(fieldName.Replace('_', ' ').ToLower());
|
|
}
|
|
|
|
column.FieldName = fieldName;
|
|
column.HeaderText = headerText;
|
|
column.ReadOnly = readOnly;
|
|
column.FormatString = formatString;
|
|
|
|
this.Columns.Add(column);
|
|
|
|
return column;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add ColumnGroup
|
|
/// </summary>
|
|
/// <param name="columnNames"></param>
|
|
/// <param name="showHeader"></param>
|
|
/// <param name="name"></param>
|
|
/// <param name="rowIndex"></param>
|
|
/// <param name="groupParent"></param>
|
|
/// <returns></returns>
|
|
public GridViewColumnGroup AddColumnGroup(List<string> columnNames, bool showHeader, string name, GridViewColumnGroup groupParent = null, int rowIndex = 0)
|
|
{
|
|
if (this.ViewDefinition.GetType() != typeof(ColumnGroupsViewDefinition)) this.ViewDefinition = new ColumnGroupsViewDefinition();
|
|
ColumnGroupsViewDefinition view = this.ViewDefinition as ColumnGroupsViewDefinition;
|
|
|
|
GridViewColumnGroup group = null;
|
|
if (groupParent != null)
|
|
{
|
|
if (!groupParent.Groups.Contains(name)) groupParent.Groups.Add(new GridViewColumnGroup(name, name));
|
|
group = groupParent.Groups[name];
|
|
}
|
|
else
|
|
{
|
|
if (!view.ColumnGroups.Contains(name)) view.ColumnGroups.Add(new GridViewColumnGroup(name, name));
|
|
group = view.ColumnGroups[name];
|
|
}
|
|
|
|
group.ShowHeader = showHeader;
|
|
|
|
while (group.Rows.Count <= rowIndex)
|
|
group.Rows.Add(new GridViewColumnGroupRow());
|
|
|
|
foreach (string columnName in columnNames)
|
|
group.Rows[rowIndex].ColumnNames.Add(columnName);
|
|
|
|
return group;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Binding data to defined columns.
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
public void AutoBinding(DataTableBase[] data, bool reset = false)
|
|
{
|
|
try
|
|
{
|
|
this.DataBindingItems.Clear();
|
|
if (data == null) return;
|
|
|
|
this.DataBindingItems.AddRange(data);
|
|
if (this.InvokeRequired)
|
|
Invoke((MethodInvoker)delegate () { this.AutoBinding_Execute(this.DataBindingItems, reset); });
|
|
else
|
|
this.AutoBinding_Execute(this.DataBindingItems, reset);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
XLogger.Instance.Fatal(ex);
|
|
}
|
|
}
|
|
|
|
private void AutoBinding_Execute(List<object> dataBoundItems, bool reset)
|
|
{
|
|
this.DataSource = null;
|
|
if (dataBoundItems == null || dataBoundItems.Count < 1) return;
|
|
|
|
// Column Setting
|
|
if (reset || this.IsSetColumn == false)
|
|
{
|
|
// Backup Columns
|
|
Dictionary<string, GridViewDataColumn> lstColumn = new Dictionary<string, GridViewDataColumn>();
|
|
foreach (GridViewDataColumn column in this.Columns)
|
|
lstColumn.Add(column.Name, column);
|
|
|
|
// Create Columns
|
|
this.Columns.Clear();
|
|
TextInfo textIF = CultureInfo.TextInfo;
|
|
|
|
DataTableBase tempData = dataBoundItems[0] as DataTableBase;
|
|
foreach (PropertyInfo property in tempData.GetType().GetProperties())
|
|
{
|
|
GridViewDataColumn column = null;
|
|
|
|
#region [ Create GridViewDataColumn ]
|
|
if (column == null && this.ComboBoxCollection.ContainsKey(property.Name))
|
|
{
|
|
column = new GridViewComboBoxColumn()
|
|
{
|
|
TextAlignment = ContentAlignment.MiddleCenter,
|
|
DataSource = this.ComboBoxCollection[property.Name],
|
|
DisplayMember = "Display",
|
|
ValueMember = "Value"
|
|
};
|
|
}
|
|
if (column == null && property.PropertyType == typeof(DateTime))
|
|
{
|
|
column = new GridViewDateTimeColumn()
|
|
{
|
|
TextAlignment = ContentAlignment.MiddleCenter,
|
|
FormatInfo = CultureInfo,
|
|
FormatString = "{0:" + CultureInfo.DateTimeFormat.ShortDatePattern + " HH:mm:ss}"
|
|
};
|
|
}
|
|
if (column == null && (property.PropertyType == typeof(int) || property.PropertyType == typeof(Int64)))
|
|
{
|
|
column = new GridViewDecimalColumn()
|
|
{
|
|
TextAlignment = ContentAlignment.MiddleRight,
|
|
FormatInfo = CultureInfo,
|
|
FormatString = "{0:#,##0}",
|
|
};
|
|
GridViewDecimalColumn decimalColumn = column as GridViewDecimalColumn;
|
|
decimalColumn.DecimalPlaces = 0;
|
|
decimalColumn.ThousandsSeparator = true;
|
|
}
|
|
if (column == null && (property.PropertyType == typeof(decimal) || property.PropertyType == typeof(Decimal)))
|
|
{
|
|
column = new GridViewDecimalColumn()
|
|
{
|
|
TextAlignment = ContentAlignment.MiddleRight,
|
|
FormatInfo = CultureInfo,
|
|
FormatString = "{0:#,##0.#####}",
|
|
};
|
|
GridViewDecimalColumn decimalColumn = column as GridViewDecimalColumn;
|
|
decimalColumn.DecimalPlaces = 6;
|
|
decimalColumn.ThousandsSeparator = true;
|
|
}
|
|
if (column == null && property.PropertyType == typeof(double))
|
|
{
|
|
column = new GridViewDecimalColumn()
|
|
{
|
|
TextAlignment = ContentAlignment.MiddleRight,
|
|
FormatInfo = CultureInfo,
|
|
FormatString = "{0:#,##0.####}",
|
|
};
|
|
GridViewDecimalColumn decimalColumn = column as GridViewDecimalColumn;
|
|
decimalColumn.DecimalPlaces = 6;
|
|
decimalColumn.ThousandsSeparator = true;
|
|
}
|
|
if (column == null)
|
|
{
|
|
column = new GridViewTextBoxColumn()
|
|
{
|
|
TextAlignment = ContentAlignment.MiddleLeft,
|
|
WrapText = true
|
|
};
|
|
}
|
|
#endregion
|
|
|
|
column.FieldName = property.Name;
|
|
column.MinWidth = 40;
|
|
|
|
if (lstColumn.ContainsKey(property.Name))
|
|
{
|
|
if (column.GetType() == lstColumn[property.Name].GetType())
|
|
{
|
|
lstColumn[property.Name].PropertiesCopy(column);
|
|
}
|
|
else
|
|
{
|
|
if (lstColumn.ContainsKey(property.Name) && lstColumn[property.Name].GetType() != typeof(GridViewTextBoxColumn))
|
|
column = lstColumn[property.Name];
|
|
|
|
column.HeaderText = lstColumn[property.Name].HeaderText;
|
|
column.ReadOnly = lstColumn[property.Name].ReadOnly;
|
|
column.IsVisible = lstColumn[property.Name].IsVisible;
|
|
if (!string.IsNullOrEmpty(lstColumn[property.Name].FormatString))
|
|
column.FormatString = lstColumn[property.Name].FormatString;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
column.HeaderText = textIF.ToTitleCase(property.Name.Replace('_', ' ').ToLower());
|
|
column.ReadOnly = true;
|
|
if (lstColumn.Count > 0) column.IsVisible = false;
|
|
}
|
|
|
|
this.Columns.Add(column);
|
|
}
|
|
|
|
// Setting Columns
|
|
int index = 0;
|
|
foreach (string name in lstColumn.Keys)
|
|
{
|
|
if (this.Columns.Contains(name) == false) this.Columns.Add(lstColumn[name]);
|
|
this.Columns.Move(this.Columns[name].Index, index++);
|
|
}
|
|
lstColumn.Clear();
|
|
|
|
this.IsSetColumn = true;
|
|
}
|
|
|
|
this.SuspendLayout();
|
|
this.DataSource = dataBoundItems;
|
|
this.ResumeLayout();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ SelectRow ] -------------------------------------------------
|
|
|
|
/// <summary>
|
|
/// Set CurrentRow
|
|
/// </summary>
|
|
/// <param name="name">Cell.Name</param>
|
|
/// <param name="value">Cell.Value</param>
|
|
/// <returns></returns>
|
|
public GridViewRowInfo SetCurrentRow(string name, string value)
|
|
{
|
|
try
|
|
{
|
|
var row = this.GetRows(name, value).FirstOrDefault();
|
|
if (row != null) this.CurrentRow = row;
|
|
|
|
return row;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Search Rows
|
|
/// </summary>
|
|
/// <param name="name">Cell.Name</param>
|
|
/// <param name="value">Cell.Value</param>
|
|
/// <returns></returns>
|
|
public GridViewRowInfo[] GetRows(string name, string value)
|
|
{
|
|
try
|
|
{
|
|
if (this.Rows.Count < 1) return null;
|
|
var rows = this.Rows.Where(item => item.Cells[name].Value.ToString() == value).ToArray();
|
|
|
|
return rows;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ SetRowForeColor ] -------------------------------------------
|
|
|
|
public void SetRowForeColor(string columnName, string condition, Color color)
|
|
{
|
|
if (!this.Columns.Contains(columnName)) return;
|
|
|
|
string name = columnName;
|
|
foreach (BaseFormattingObject item in this.Columns[columnName].ConditionalFormattingObjectList)
|
|
{
|
|
if (item.Name == name)
|
|
{
|
|
if (item.GetType() == typeof(ExpressionFormattingObject))
|
|
{
|
|
ExpressionFormattingObject obj = item as ExpressionFormattingObject;
|
|
if (obj.Expression == condition) return;
|
|
}
|
|
}
|
|
}
|
|
|
|
ExpressionFormattingObject formatting = new ExpressionFormattingObject(name, condition, true);
|
|
formatting.RowForeColor = color;
|
|
this.Columns[columnName].ConditionalFormattingObjectList.Add(formatting);
|
|
}
|
|
|
|
public void SetCellForeColor(string columnName, string condition, Color color)
|
|
{
|
|
if (!this.Columns.Contains(columnName)) return;
|
|
|
|
string name = columnName;
|
|
foreach (BaseFormattingObject item in this.Columns[columnName].ConditionalFormattingObjectList)
|
|
{
|
|
if (item.Name == name)
|
|
{
|
|
if (item.GetType() == typeof(ExpressionFormattingObject))
|
|
{
|
|
ExpressionFormattingObject obj = item as ExpressionFormattingObject;
|
|
if (obj.Expression == condition) return;
|
|
}
|
|
}
|
|
}
|
|
|
|
ExpressionFormattingObject formatting = new ExpressionFormattingObject(name, condition, true);
|
|
formatting.CellForeColor = color;
|
|
this.Columns[columnName].ConditionalFormattingObjectList.Add(formatting);
|
|
}
|
|
|
|
public void SetRowBackColor(string columnName, string condition, Color color)
|
|
{
|
|
if (!this.Columns.Contains(columnName)) return;
|
|
|
|
string name = columnName;
|
|
foreach (BaseFormattingObject item in this.Columns[columnName].ConditionalFormattingObjectList)
|
|
{
|
|
if (item.Name == name)
|
|
{
|
|
if (item.GetType() == typeof(ExpressionFormattingObject))
|
|
{
|
|
ExpressionFormattingObject obj = item as ExpressionFormattingObject;
|
|
if (obj.Expression == condition) return;
|
|
}
|
|
}
|
|
}
|
|
|
|
ExpressionFormattingObject formatting = new ExpressionFormattingObject(name, condition, true);
|
|
formatting.RowBackColor = color;
|
|
this.Columns[columnName].ConditionalFormattingObjectList.Add(formatting);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ ContextMenu ] -----------------------------------------------
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="text"></param>
|
|
/// <param name="method"></param>
|
|
/// <param name="separator"></param>
|
|
/// <param name="args"></param>
|
|
public RadMenuItem AddContextMenu(string text, ContextMenuHandler method = null, bool separator = false, object[] args = null)
|
|
{
|
|
if (this.ContextMenu == null) this.ContextMenu = new RadContextMenu();
|
|
|
|
if (string.IsNullOrWhiteSpace(text)) { this.ContextMenu.Items.Add(new RadMenuSeparatorItem()); return null; }
|
|
if (separator) this.ContextMenu.Items.Add(new RadMenuSeparatorItem());
|
|
|
|
RadMenuItem item = new RadMenuItem(text);
|
|
item.Name = text;
|
|
if (method != null) item.Click += new EventHandler(delegate (object sender, EventArgs arg) { method(item, args); });
|
|
|
|
this.ContextMenu.Items.Add(item);
|
|
return item;
|
|
}
|
|
|
|
public RadMenuItem InsertContextMenu(int index, string text, ContextMenuHandler method = null, bool separator = false, object[] args = null)
|
|
{
|
|
if (this.ContextMenu == null) this.ContextMenu = new RadContextMenu();
|
|
|
|
if (string.IsNullOrWhiteSpace(text)) { this.ContextMenu.Items.Add(new RadMenuSeparatorItem()); return null; }
|
|
if (separator) this.ContextMenu.Items.Add(new RadMenuSeparatorItem());
|
|
|
|
RadMenuItem item = new RadMenuItem(text);
|
|
item.Name = text;
|
|
if (method != null) item.Click += new EventHandler(delegate (object sender, EventArgs arg) { method(item, args); });
|
|
|
|
if (index > this.ContextMenu.Items.Count) index = this.ContextMenu.Items.Count;
|
|
this.ContextMenu.Items.Insert(index, item);
|
|
return item;
|
|
}
|
|
|
|
public RadMenuItem AddContextMenu(string text, bool isChecked, ContextMenuHandler method = null, bool separator = false, object[] args = null)
|
|
{
|
|
RadMenuItem item = this.AddContextMenu(text, method, separator, args);
|
|
item.CheckOnClick = true;
|
|
item.IsChecked = isChecked;
|
|
|
|
return item;
|
|
}
|
|
|
|
public RadMenuItem AddContextMenu(RadMenuItem parent, string text, ContextMenuHandler method = null, bool separator = false, object[] args = null)
|
|
{
|
|
if (separator) parent.Items.Add(new RadMenuSeparatorItem());
|
|
|
|
RadMenuItem item = new RadMenuItem(text);
|
|
item.Name = text;
|
|
if (method != null) item.Click += new EventHandler(delegate (object sender, EventArgs arg) { method(args); });
|
|
|
|
parent.Items.Add(item);
|
|
return item;
|
|
}
|
|
|
|
public RadMenuItem InsertContextMenu(RadMenuItem parent, int index, string text, ContextMenuHandler method = null, bool separator = false, object[] args = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(text)) { parent.Items.Insert(index, new RadMenuSeparatorItem()); return null; }
|
|
if (separator) parent.Items.Add(new RadMenuSeparatorItem());
|
|
|
|
RadMenuItem item = new RadMenuItem(text);
|
|
item.Name = text;
|
|
if (method != null) item.Click += new EventHandler(delegate (object sender, EventArgs arg) { method(args); });
|
|
|
|
parent.Items.Insert(index, item);
|
|
return item;
|
|
}
|
|
|
|
public bool RemoveContextMenu(string text)
|
|
{
|
|
foreach (RadItem item in this.ContextMenu.Items)
|
|
{
|
|
if (item.Text == text)
|
|
{
|
|
this.ContextMenu.Items.Remove(item);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ ExportExcel ] -----------------------------------------------
|
|
|
|
public delegate void ExportExcelClickHandler(object sender, ExportExcelClickArgument arg);
|
|
|
|
public event ExportExcelClickHandler ExportExcelClick;
|
|
|
|
private void ExportExcelDialog(object sender, params object[] args)
|
|
{
|
|
ExportExcelClickArgument arg = new ExportExcelClickArgument();
|
|
if (this.ExportExcelClick != null) this.ExportExcelClick(this, arg);
|
|
if (arg.Cancel) return;
|
|
|
|
SaveFileDialog dlg = new SaveFileDialog();
|
|
dlg.InitialDirectory = $"{arg.InitialDirectory}";
|
|
dlg.Filter = "Excel File|*.xlsx|All Childs|*.*";
|
|
dlg.DefaultExt = "xlsx";
|
|
dlg.FileName = $"{arg.FileName}";
|
|
if (dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
this.ExportExcel(dlg.FileName);
|
|
if (arg.FolderOpen)
|
|
{
|
|
string command = $"/select,{dlg.FileName}";
|
|
System.Diagnostics.Process.Start($"explorer.exe", command);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ExportExcel(string fileName)
|
|
{
|
|
try
|
|
{
|
|
GridViewSpreadStreamExport export = new GridViewSpreadStreamExport(this);
|
|
export.HiddenColumnOption = Telerik.WinControls.UI.Export.HiddenOption.DoNotExport;
|
|
export.HiddenRowOption = Telerik.WinControls.UI.Export.HiddenOption.DoNotExport;
|
|
export.FreezeHeaderRow = true;
|
|
|
|
export.RunExport(fileName, new SpreadStreamExportRenderer());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
XLogger.Instance.Fatal(ex);
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ ColumnVisible ] ---------------------------------------------
|
|
|
|
public RadMenuItem AddContextMenuColumnVisible()
|
|
{
|
|
TextInfo textIF = CultureInfo.TextInfo;
|
|
|
|
RadMenuItem menu = this.ContextMenu.Items["COLUMNS_VISIBLE"] as RadMenuItem;
|
|
if (menu == null)
|
|
{
|
|
menu = new RadMenuItem("Columns Visible");
|
|
menu.Name = "COLUMNS_VISIBLE";
|
|
this.ContextMenu.Items.Add(menu);
|
|
}
|
|
|
|
foreach (GridViewDataColumn column in this.Columns)
|
|
{
|
|
string text = textIF.ToTitleCase(column.Name.Replace('_', ' ').ToLower());
|
|
if (column.Tag != null && column.Tag.GetType() == typeof(string)) text = textIF.ToTitleCase(((string)column.Tag).Replace('_', ' ').ToLower());
|
|
|
|
RadMenuItem item = new RadMenuItem(text);
|
|
item.CheckOnClick = true;
|
|
item.IsChecked = false;
|
|
item.Tag = column.Name;
|
|
item.Click += this.ColumnVisible_Click;
|
|
if (column.IsVisible) item.IsChecked = true;
|
|
|
|
menu.Items.Add(item);
|
|
}
|
|
|
|
return menu;
|
|
}
|
|
|
|
public RadMenuItem SetValueColumnVisible()
|
|
{
|
|
RadMenuItem menu = this.ContextMenu.Items["COLUMNS_VISIBLE"] as RadMenuItem;
|
|
if (menu == null) return null;
|
|
|
|
foreach (RadMenuItem item in menu.Items)
|
|
{
|
|
if (item.Tag == null || item.Tag.GetType() != typeof(string)) continue;
|
|
string columnName = item.Tag.ToString();
|
|
if (!this.Columns.Contains(columnName)) continue;
|
|
|
|
GridViewDataColumn column = this.Columns[columnName];
|
|
item.IsChecked = column.IsVisible;
|
|
}
|
|
|
|
return menu;
|
|
}
|
|
|
|
private void ColumnVisible_Click(object sender, EventArgs e)
|
|
{
|
|
RadMenuItem item = (RadMenuItem)sender;
|
|
string name = item.Tag as string;
|
|
GridViewDataColumn column = this.Columns[name];
|
|
column.IsVisible = item.IsChecked;
|
|
//this.BestFitColumns();
|
|
}
|
|
|
|
private void ColumnVisible(params object[] args)
|
|
{
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ Grouping ] --------------------------------------------------
|
|
|
|
private object PerformGrouping(GridViewRowInfo row, int level)
|
|
{
|
|
GroupDescriptor groupDescriptor = this.GroupDescriptors[level];
|
|
object[] key = new object[groupDescriptor.GroupNames.Count];
|
|
|
|
for (int i = 0; i < groupDescriptor.GroupNames.Count; i++)
|
|
{
|
|
SortDescriptor descriptor = groupDescriptor.GroupNames[i];
|
|
int index = descriptor.PropertyIndex;
|
|
if (index < 0) continue;
|
|
|
|
key[i] = this.GetGroupKey(row, descriptor);
|
|
}
|
|
|
|
return key;
|
|
}
|
|
|
|
public virtual object GetGroupKey(GridViewRowInfo row, SortDescriptor descriptor)
|
|
{
|
|
int index = descriptor.PropertyIndex;
|
|
object keyValue = row.Cells[index].Value;
|
|
GridViewDateTimeColumn column = row.Cells[index].ColumnInfo as GridViewDateTimeColumn;
|
|
|
|
if (keyValue == DBNull.Value)
|
|
{
|
|
keyValue = null;
|
|
}
|
|
else if (column != null)
|
|
{
|
|
DateTime value = (DateTime)keyValue;
|
|
StringBuilder sb = new StringBuilder();
|
|
if (this.DateTimeGroupKey != eDateTimeGroupKey.None)
|
|
{
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Year) > 0) sb.Append("yyyy");
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Month) > 0)
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Year) > 0) sb.Append("-MM");
|
|
else sb.Append("MM");
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Day) > 0)
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Month) > 0) sb.Append("-dd");
|
|
else sb.Append("dd");
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Hour) > 0)
|
|
if (sb.Length > 0) sb.Append(" HH");
|
|
else sb.Append("HH");
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Minute) > 0)
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Hour) > 0) sb.Append(":mm");
|
|
else sb.Append("mm");
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Second) > 0)
|
|
if ((this.DateTimeGroupKey & eDateTimeGroupKey.Minute) > 0) sb.Append(":ss");
|
|
else sb.Append("ss");
|
|
}
|
|
keyValue = ((DateTime)keyValue).ToString(sb.ToString());
|
|
}
|
|
|
|
return keyValue;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region [ ETC ] -------------------------------------------------------
|
|
|
|
public int GetVisualRows_FirstDataRowIndex()
|
|
{
|
|
int index = -1;
|
|
try
|
|
{
|
|
foreach (GridRowElement element in this.TableElement.VisualRows)
|
|
{
|
|
if (element.RowInfo is GridViewDataRowInfo)
|
|
{
|
|
index = element.RowInfo.Index;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
XLogger.Instance.Fatal(ex);
|
|
return index;
|
|
}
|
|
}
|
|
|
|
private void Clipboard_CurrentCellValue(object sender, params object[] args)
|
|
{
|
|
try
|
|
{
|
|
Clipboard.SetText($"{this.CurrentCell?.Text}");
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
private void Clipboard_CurrentRowValue(object sender, params object[] args)
|
|
{
|
|
try
|
|
{
|
|
StringBuilder sbRow = new StringBuilder();
|
|
foreach (GridViewRowInfo row in this.SelectedRows)
|
|
{
|
|
StringBuilder sbCell = new StringBuilder();
|
|
foreach (GridViewCellInfo cell in row.Cells)
|
|
{
|
|
if (!cell.ColumnInfo.IsVisible) continue;
|
|
if (sbCell.Length > 0) sbCell.Append("\t");
|
|
sbCell.AppendFormat($"{cell?.Value}");
|
|
}
|
|
sbRow.AppendLine(sbCell.ToString());
|
|
}
|
|
Clipboard.SetText(sbRow.ToString());
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
private void ShowColumnChooser(object sender, params object[] args)
|
|
{
|
|
this.ShowColumnChooser();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
public class ComboBoxItem
|
|
{
|
|
|
|
public string Display { get; set; } = string.Empty;
|
|
|
|
public object Value { get; set; } = null;
|
|
|
|
public ComboBoxItem()
|
|
{
|
|
}
|
|
|
|
public ComboBoxItem(string display, object value)
|
|
{
|
|
this.Display = display;
|
|
this.Value = value;
|
|
}
|
|
|
|
}
|
|
|
|
public class ExportExcelClickArgument
|
|
{
|
|
|
|
public bool Cancel { get; set; } = false;
|
|
|
|
public string InitialDirectory { get; set; } = $"{Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)}";
|
|
|
|
public string FileName { get; set; } = $"";
|
|
|
|
public bool FolderOpen { get; set; } = true;
|
|
|
|
public ExportExcelClickArgument()
|
|
{
|
|
}
|
|
|
|
}
|
|
|
|
public class CustomerExpressionContext : Telerik.Data.Expressions.ExpressionContext
|
|
{
|
|
|
|
public string Int2Hex(string strDecimal)
|
|
{
|
|
int value = 0;
|
|
if (int.TryParse(strDecimal, out value) == false) return string.Empty;
|
|
return $"0x{value.ToString("x")}";
|
|
}
|
|
|
|
}
|
|
|
|
}
|