/// <summary>
/// Data source has changed
/// </summary>
/// <param name="sender">Sender of event</param>
/// <param name="e">Event arguments</param>
private void OnComboBox1Changed(object sender, EventArgs e)
{
if (DataSourceChanged != null)
{
DataSourceChanged.Invoke(sender, e);
}
}
private async Task LoadChildrenAsync(TreeItemBase row, bool autoExpand)
{
row.Expanded = true;
row.IsLoading = true;
Refresh();
var newDataSource = await FetchChildrenAsync(row);
row.IsLoading = false;
var enumerbale = DataSource as IEnumerable;
var startIndex = 0;
foreach (var item in enumerbale)
{
if (item == row)
{
break;
}
startIndex++;
}
var oldDataSource = enumerbale.Cast <object>().ToList();
oldDataSource.InsertRange(startIndex + 1, (newDataSource as IEnumerable).Cast <object>());
DataSource = oldDataSource;
await InitlizeDataSourceAsync(row.Level.Value + 1, "up", autoExpand);
if (DataSourceChanged.HasDelegate)
{
await DataSourceChanged.InvokeAsync(DataSource);
}
SyncFieldValue();
}
public XGrid()
{
InitializeComponent();
Initialize();
InitializeEvents();
_PrintableComponentLink.CreateReportHeaderArea += delegate(object sender, CreateAreaEventArgs e)
{
if (PrintHeader.IsNullOrEmpty() == false)
{
e.Graph.StringFormat = new BrickStringFormat(StringAlignment.Center);
e.Graph.Font = new Font(SystemFonts.DefaultFont.FontFamily, 14f, FontStyle.Bold);
var rect = new RectangleF(0, 0, e.Graph.ClientPageSize.Width, 50);
e.Graph.DrawString(PrintHeader, Color.Black, rect, BorderSide.None);
}
};
_PrintableComponentLink.CreateReportFooterArea += delegate(object sender, CreateAreaEventArgs e)
{
if (PrintFooter.IsNullOrEmpty() == false)
{
e.Graph.StringFormat = new BrickStringFormat(StringAlignment.Near);
e.Graph.Font = new Font(SystemFonts.DefaultFont.FontFamily, 10f, FontStyle.Regular);
var rect = new RectangleF(0, e.Graph.ClientPageSize.Height - 50, e.Graph.ClientPageSize.Width, 50);
e.Graph.DrawString(PrintHeader, Color.Black, rect, BorderSide.None);
}
};
_GridView.PopupMenuShowing += GridViewPopupMenuShowing;
_BandedGridView.PopupMenuShowing += BandedGridViewPopupMenuShowing;
_AdvBandedGridView.PopupMenuShowing += BandedGridViewPopupMenuShowing;
GridLocalizer.Active = new KoreanGridLocalizer();
Grid.DataSourceChanged += delegate(object sender, EventArgs e) { DataSourceChanged?.Invoke(sender, e); };
}
protected override void RaiseDataSourceChangedEvent(EventArgs e)
{
base.RaiseDataSourceChangedEvent(e);
if (DataSourceChanged != null)
{
DataSourceChanged.Invoke(this, EventArgs.Empty);
}
}
private async Task SaveTableAsync(KeyboardEventArgs e)
{
if (e.Code != "Enter")
{
return;
}
var keyValueModels = DataSource as List <KeyValueModel>;
if (string.IsNullOrWhiteSpace(Url) && (DataSource == null || keyValueModels != null))
{
var keyHeader = Headers.FirstOrDefault(x => x.Property.Name == "Key");
var txtKey = keyHeader.EditingValue?.Trim();
if (string.IsNullOrWhiteSpace(txtKey))
{
return;
}
var valueHeader = Headers.FirstOrDefault(x => x.Property.Name == "Value");
var txtValue = valueHeader.EditingValue?.Trim();
txtKey = txtKey.Trim();
if (keyValueModels == null)
{
DataSource = keyValueModels = new List <KeyValueModel>();
}
var existKeyValueModel = keyValueModels.FirstOrDefault(x => x.Key == txtKey);
if (existKeyValueModel == null)
{
keyValueModels.Add(new KeyValueModel()
{
Key = txtKey,
Value = txtValue
});
}
else
{
existKeyValueModel.Value = txtValue;
}
keyHeader.EditingValue = string.Empty;
valueHeader.EditingValue = null;
await InitlizeDataSourceAsync(0, string.Empty, true);
if (editingRow != null)
{
editingRow = null;
}
if (DataSourceChanged.HasDelegate)
{
await DataSourceChanged.InvokeAsync(DataSource);
}
SyncFieldValue();
return;
}
await SaveDataAsync(saveAction);
}
internal async Task RefreshDataSourceAsync(bool autoExpand)
{
if (!string.IsNullOrWhiteSpace(Url))
{
DataSource = await httpClient.GetFromJsonAsync(Url, typeof(List <>).MakeGenericType(DataType));
if (DataSourceChanged.HasDelegate)
{
await DataSourceChanged.InvokeAsync(DataSource);
}
}
await InitlizeDataSourceAsync(0, "up", autoExpand);
}
private async Task ToggleTreeAsync(object row)
{
var treeRow = row as TreeItemBase;
if (treeRow == null || treeRow.IsLoading)
{
return;
}
var finalChildren = GetAllChildren(treeRow);
if (string.IsNullOrWhiteSpace(Url))
{
if (!treeRow.Expanded)
{
LocalExpand(treeRow, finalChildren);
}
else
{
hiddenRows.AddRange(finalChildren);
treeRow.Direction = "up";
treeRow.Expanded = false;
}
}
else
{
if (treeRow.Expanded)
{
treeRow.Expanded = false;
rows.RemoveAll(finalChildren.Contains);
DataSource = rows;
await InitlizeDataSourceAsync(0, "up", false);
if (DataSourceChanged.HasDelegate)
{
await DataSourceChanged.InvokeAsync(DataSource);
}
SyncFieldValue();
treeRow.Direction = "up";
}
else
{
await LoadChildrenAsync(treeRow, false);
}
}
MarkAsRequireRender();
}
private void ListDataSource_ListChanged(object sender, ListChangedEventArgs e)
{
var bindingList = (BindingList <GroupViewItem>)sender;
DataSourceChanged?.Invoke(bindingList.ToList(), new EventArgs());
var group = bindingList.ElementAtOrDefault(e.NewIndex);
switch (e.ListChangedType)
{
case ListChangedType.ItemAdded:
AddNewGroup(group);
break;
case ListChangedType.ItemChanged:
break;
}
}
public bool Unsubscribe(DataSourceChangedEventHandler subscriber)
{
if (DataSourceChanged == null)
{
return(false); // It's not there.
}
else
{
Delegate[] subscriberList = DataSourceChanged.GetInvocationList();
if (subscriberList.FirstOrDefault((x) => x == (Delegate)subscriber) == null)
{
return(false); // Not there.
}
else
{
DataSourceChanged -= subscriber;
return(true); // We removed it.
}
}
}
public bool Subscribe(DataSourceChangedEventHandler subscriber)
{
if (DataSourceChanged == null)
{
DataSourceChanged = subscriber;
return(true); // We added it.
}
else
{
Delegate[] subscriberList = DataSourceChanged.GetInvocationList();
if (subscriberList.FirstOrDefault((x) => x == (Delegate)subscriber) == null)
{
DataSourceChanged += subscriber;
return(true); // We added it.
}
else
{
return(false); // Already there.
}
}
}
private void Box_DataSourceChanged(object sender, EventArgs e)
{
DataSourceChanged?.Invoke(sender, e);
}
public BaseGiftDataProvider(IGiftDatabase database)
{
this.Database = database;
this.Database.DatabaseChanged += () => DataSourceChanged?.Invoke();
}
/// <summary>
/// constructor
/// </summary>
/// <param name="type">the type of the change</param>
public DataSourceChangedEventArgs(DataSourceChanged type)
{
ChangeType = type;
}
private void Provider_DataSourceChanged
(object sender, DataSourceChangedEventArgs e)
=> DataSourceChanged?.Invoke(sender, e);
private void UpdateFileStatusListView(bool updateCausedByFilter = false)
{
if (!GitItemStatuses.Any())
{
HandleVisibility_NoFilesLabel_FilterComboBox(filesPresent: false);
}
else
{
EnsureSelectedIndexChangeSubscription();
HandleVisibility_NoFilesLabel_FilterComboBox(filesPresent: true);
}
FileStatusListView.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
var previouslySelectedItems = new List <GitItemStatus>();
if (updateCausedByFilter)
{
foreach (ListViewItem Item in FileStatusListView.SelectedItems)
{
previouslySelectedItems.Add(Item.Tag as GitItemStatus);
}
DataSourceChanged?.Invoke(this, new EventArgs());
}
FileStatusListView.BeginUpdate();
FileStatusListView.ShowGroups = GitItemStatusesWithParents.Count > 1;
FileStatusListView.Groups.Clear();
FileStatusListView.Items.Clear();
var clientSizeWidth = AppSettings.TruncatePathMethod == "compact" || AppSettings.TruncatePathMethod == "trimstart";
var fileNameOnlyMode = AppSettings.TruncatePathMethod == "fileNameOnly";
var list = new List <ListViewItem>();
foreach (var pair in GitItemStatusesWithParents)
{
ListViewGroup group = null;
if (pair.Key != null)
{
var groupName = "";
if (pair.Key.Guid == CombinedDiff.Text)
{
groupName = CombinedDiff.Text;
}
else
{
groupName = _DiffWithParent.Text + " " + GetDescriptionForRevision(pair.Key.Guid);
}
group = new ListViewGroup(groupName);
group.Tag = pair.Key;
FileStatusListView.Groups.Add(group);
}
foreach (var item in pair.Value)
{
if (_filter.IsMatch(item.Name))
{
var text = item.Name;
if (clientSizeWidth)
{
// list-item has client width, so we don't need horizontal scrollbar (which is determined by this text width)
text = string.Empty;
}
else if (fileNameOnlyMode)
{
// we need to put filename in list-item text -> then horizontal scrollbar
// will have proper width (by the longest filename, and not all path)
text = PathFormatter.FormatTextForFileNameOnly(item.Name, item.OldName);
text = AppendItemSubmoduleStatus(text, item);
}
var listItem = new ListViewItem(text, group);
listItem.ImageIndex = GetItemImageIndex(item);
if (item.SubmoduleStatus != null && !item.SubmoduleStatus.IsCompleted)
{
var capturedItem = item;
item.SubmoduleStatus.ContinueWith((task) => listItem.ImageIndex = GetItemImageIndex(capturedItem),
CancellationToken.None,
TaskContinuationOptions.OnlyOnRanToCompletion,
TaskScheduler.FromCurrentSynchronizationContext());
}
if (previouslySelectedItems.Contains(item))
{
listItem.Selected = true;
}
listItem.Tag = item;
list.Add(listItem);
}
}
}
FileStatusListView.Items.AddRange(list.ToArray());
if (updateCausedByFilter == false)
{
FileStatusListView_SelectedIndexChanged();
DataSourceChanged?.Invoke(this, new EventArgs());
if (SelectFirstItemOnSetItems)
{
SelectFirstVisibleItem();
}
}
FileStatusListView_SizeChanged(null, null);
FileStatusListView.SetGroupState(ListViewGroupState.Collapsible);
FileStatusListView.EndUpdate();
}
protected void RaiseDataSourceChanged(PointDataSourceBase prevSource, PointDataSourceBase currSource)
{
DataSourceChanged.Raise(this, prevSource, currSource);
}
protected virtual void OnDataSourceChanged(EventArgs e)
{
DataSourceChanged?.Invoke(this, e);
}
private void TranslationsManager_DataSourceChanged(object sender, DataSourceChangedEventArgs e) => DataSourceChanged?.Invoke(sender, e);
private void Dgv_DataSourceChanged(object sender, EventArgs e)
{
DataSourceChanged?.Invoke();
}
public virtual void OnDataSourceChanged(object sender, DataSourceChangeEventArgs e){
DataSourceChanged.Raise (this, e);
#if DEBUG_BINDING
Debug.WriteLine("New DataSource for => {0} \n\t{1}=>{2}", this.ToString(),e.OldDataSource,e.NewDataSource);
#endif
}