private void UCIndexCreator_Load(object sender, EventArgs e)
{
LoadTreeView();
TheWatcher = new FileWatcher();
//Apply previous treeview state (expand and checked)
TreeViewState tvState = TreeViewExtensions.DeserializeTreeViewState();
if (tvState != null)
{
treeViewFolders.BeginUpdate();
// Once it is populated, we need to restore expanded nodes
treeViewFolders.Nodes.SetExpansionState(tvState.ExpandedList);
treeViewFolders.Nodes.SetCheckedState(tvState.CheckedList);
//Integrate filewatcher to get notification on file modifications based on previous folder selection
TheWatcher.RefreshWatchers();
TheWatcher.OnFileChange += Fw_OnFileChange;
TheWatcher.ConfigureFileWatcher(tvState.CheckedList);
treeViewFolders.EndUpdate();
}
GetCheckedNodes(treeViewFolders.Nodes);
}
public void FormClosing()
{
if (searchForm != null)
{
searchForm.OnControlClosing();
searchForm.Dispose();
}
foreach (var control in stPanel2.Controls)
{
if (control is STUserControl)
{
((STUserControl)control).OnControlClosing();
}
}
foreach (var node in TreeViewExtensions.Collect(treeViewCustom1.Nodes))
{
if (node is ArchiveRootNodeWrapper)
{
var file = ((ArchiveRootNodeWrapper)node).ArchiveFile;
((IFileFormat)file).Unload();
}
else if (node is IFileFormat)
{
((IFileFormat)node).Unload();
}
}
ClearNodes();
}
private void btnCreateIndex_Click(object sender, EventArgs e)
{
selectedFolders.Clear();
GetCheckedNodes(treeViewFolders.Nodes);
if (selectedFolders.Count <= 0)
{
MessageBox.Show("No folders selected !");
return;
}
//keep treeview state
TreeViewState obj = new TreeViewState();
obj.ExpandedList = treeViewFolders.Nodes.GetExpansionState();
obj.CheckedList = treeViewFolders.Nodes.GetCheckedState();
TreeViewExtensions.SerializeTreeViewState(obj);
//Integrate filewatcher to get notification on file modifications.
TheWatcher.RefreshWatchers();
TheWatcher.OnFileChange += Fw_OnFileChange;
TheWatcher.ConfigureFileWatcher(selectedFolders);
CreateIndex();
//MessageBox.Show("Index Creation Completed");
}
/// <summary>
/// Creates a new command node according to the command configuration.
/// </summary>
private static TreeNode CreateCommandNode(CommandConfig commandConfig)
{
return(TreeViewExtensions.CreateNode(
GetDisplayName(commandConfig.DisplayName, DriverPhrases.UnnamedCommand),
ImageKey.Command,
commandConfig));
}
/// <summary>
/// Creates a new monitored item node according to the item configuration.
/// </summary>
private static TreeNode CreateItemNode(ItemConfig itemConfig)
{
return(TreeViewExtensions.CreateNode(
GetDisplayName(itemConfig.DisplayName, DriverPhrases.UnnamedItem),
ImageKey.Variable,
itemConfig));
}
/// <summary>
/// Fills the tree view.
/// </summary>
private void FillTreeView()
{
try
{
treeView.BeginUpdate();
treeView.Nodes.Clear();
foreach (Device device in configDatabase.DeviceTable.EnumerateItems())
{
string nodeText = string.Format(CommonPhrases.EntityCaption, device.DeviceNum, device.Name);
TreeNode deviceNode = TreeViewExtensions.CreateNode(nodeText, "device.png");
deviceNode.ContextMenuStrip = cmsDevice;
deviceNode.Tag = device;
deviceNode.Nodes.Add(TreeViewExtensions.CreateNode(CommonPhrases.EmptyData, "empty.png"));
treeView.Nodes.Add(deviceNode);
}
TreeNode emptyDeviceNode = TreeViewExtensions.CreateNode(AdminPhrases.EmptyDevice, "device.png");
emptyDeviceNode.ContextMenuStrip = cmsDevice;
emptyDeviceNode.Tag = new Device {
DeviceNum = 0, Name = AdminPhrases.EmptyDevice
};
emptyDeviceNode.Nodes.Add(TreeViewExtensions.CreateNode(CommonPhrases.EmptyData, "empty.png"));
treeView.Nodes.Add(emptyDeviceNode);
}
finally
{
treeView.EndUpdate();
}
}
private void ObjectEditor_FormClosed(object sender, FormClosedEventArgs e)
{
Viewport viewport = LibraryGUI.Instance.GetActiveViewport();
if (viewport != null)
{
viewport.FormClosing();
}
foreach (var control in stPanel2.Controls)
{
if (control is STUserControl)
{
((STUserControl)control).OnControlClosing();
}
}
foreach (var node in TreeViewExtensions.Collect(treeViewCustom1.Nodes))
{
if (node is IFileFormat)
{
((IFileFormat)node).Unload();
}
}
treeViewCustom1.Nodes.Clear();
}
protected override void Unsubscribe()
{
if (treeView != null)
{
TreeViewExtensions.GetColumns(treeView)?.ForEach(i => i.VisibilityChanged -= OnColumnVisibilityChanged);
}
}
/// <summary>
/// Creates a new subscription node according to the subscription configuration.
/// </summary>
private static TreeNode CreateSubscriptionNode(SubscriptionConfig subscriptionConfig)
{
return(TreeViewExtensions.CreateNode(
GetDisplayName(subscriptionConfig.DisplayName, DriverPhrases.UnnamedSubscription),
ImageKey.FolderClosed,
subscriptionConfig));
}
public MainWindow() : base(Gtk.WindowType.Toplevel)
{
Build();
string connectionString = "Server=localhost;Database=dbprueba;User Id=dbprueba;Password=sistemas";
ApplicationContext.Instance.DbConnection = new NpgsqlConnection(connectionString);
dbConnection = ApplicationContext.Instance.DbConnection;
dbConnection.Open();
IDbCommand dbCommand = dbConnection.CreateCommand();
dbCommand.CommandText =
"select a.id, a.nombre, a.precio, c.nombre as categoria " +
"from articulo a left join categoria c " +
"on a.categoria = c.id";
IDataReader dataReader = dbCommand.ExecuteReader();
TreeViewExtensions.Fill(treeView, dataReader);
dataReader.Close();
dataReader = dbCommand.ExecuteReader();
TreeViewExtensions.Fill(treeView, dataReader);
dataReader.Close();
}
private List <STGenericTexture> GetTextures(IFileFormat Format)
{
var Textures = new List <STGenericTexture>();
if (Format is STGenericTexture)
{
Textures.Add((STGenericTexture)Format);
}
if (Format is TreeNodeFile)
{
foreach (var node in TreeViewExtensions.Collect(((TreeNodeFile)Format).Nodes))
{
if (node is STGenericTexture)
{
Textures.Add((STGenericTexture)node);
}
else if (node is IFileFormat)
{
GetTextures((IFileFormat)node);
}
}
}
return(Textures);
}
/// <summary>
/// Creates a node that represents the configuration database.
/// </summary>
private TreeNode CreateConfigDatabaseNode(ConfigDatabase configDatabase)
{
TreeNode configDatabaseNode = TreeViewExtensions.CreateNode(AppPhrases.ConfigDatabaseNode, "database.png");
configDatabaseNode.Tag = new TreeNodeTag(project.ConfigDatabase, ExplorerNodeType.ConfigDatabase);
// primary tables sorted in the order they are configured
TreeNode primaryNode = TreeViewExtensions.CreateNode(AppPhrases.PrimaryTablesNode, "folder_closed.png");
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.ObjTable));
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.CommLineTable));
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.DeviceTable));
TreeNode cnlTableNode = CreateBaseTableNode(configDatabase.CnlTable);
cnlTableNode.ContextMenuStrip = contextMenus.CnlTableMenu;
primaryNode.Nodes.Add(cnlTableNode);
FillCnlTableNodeInternal(cnlTableNode, configDatabase);
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.LimTable));
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.ViewTable));
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.RoleTable));
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.RoleRefTable));
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.ObjRightTable));
primaryNode.Nodes.Add(CreateBaseTableNode(configDatabase.UserTable));
configDatabaseNode.Nodes.Add(primaryNode);
// secondary tables in alphabetical order
TreeNode secondaryNode = TreeViewExtensions.CreateNode(AppPhrases.SecondaryTablesNode, "folder_closed.png");
SortedList <string, TreeNode> secondaryNodes = new()
{
{ configDatabase.ArchiveTable.Title, CreateBaseTableNode(configDatabase.ArchiveTable) },
{ configDatabase.CnlStatusTable.Title, CreateBaseTableNode(configDatabase.CnlStatusTable) },
private void DownB_Click(object sender, EventArgs e)
{
if (MainTree.SelectedNode != null)
{
TreeViewExtensions.MoveBranchDown(MainTree.SelectedNode);
}
}
/// <summary>
/// Associate the parent TreeViewItem with the CheckBox.
/// </summary>
private void AssociateParentTreeViewItem()
{
_parent = TreeViewExtensions.GetParentItemsControl(this) as TreeViewItem;
if (_parent != null)
{
TreeViewExtensions.SetAssociatedCheckBox(_parent, this);
}
}
/// <summary>
/// Update the TreeViewItem's IsChecked property when this IsChecked
/// property is changed.
/// </summary>
/// <param name="sender">The CheckBox.</param>
/// <param name="e">Event arguments.</param>
private void OnIsCheckedChanged(object sender, RoutedEventArgs e)
{
TreeViewItem item = ParentTreeViewItem;
if (item != null)
{
TreeViewExtensions.SetIsChecked(item, IsChecked);
}
}
/// <summary>
/// Event handler for Edit Button Click Event
/// </summary>
/// <param name="sender">Edit Button</param>
/// <param name="e">Event arguements for event</param>
private void EditButton_Click(object sender, RoutedEventArgs e)
{
EnalbleEditForSelectedItem();
TreeViewItem selectedTreeViewItem =
TreeViewExtensions.GetContainerFromItem(TreeViewMain, selectedNode);
HideContextMenu();
}
protected override void Show(TreeViewColumn column)
{
var index
= TreeViewExtensions.GetColumns(treeView).IndexOf(column);
var content
= Children.OfType <ContentPresenter>().First(i => GetColumn(i) == index);
Show(column, content, index);
}
//...
protected override void Subscribe()
{
if (treeView != null)
{
if (TreeViewExtensions.GetMode(treeView) == TreeViewModes.Grid)
{
TreeViewExtensions.GetColumns(treeView)?.ForEach(i => i.VisibilityChanged += OnColumnVisibilityChanged);
}
}
}
private void treeViewCustom1_DrawNode(object sender, DrawTreeNodeEventArgs e)
{
e.DrawDefault = true;
bool IsCheckable = (e.Node is STGenericObject || e.Node is STGenericModel ||
e.Node is STBone);
if (!IsCheckable)
{
TreeViewExtensions.HideCheckBox(e.Node);
}
}
public void FormClosing()
{
foreach (var node in TreeViewExtensions.Collect(treeViewCustom1.Nodes))
{
if (node is IFileFormat)
{
((IFileFormat)node).Unload();
}
}
ClearNodes();
}
/// <summary>
///
/// </summary>
protected override void OnPreviewMouseLeftButtonUp(MouseButtonEventArgs e)
{
base.OnPreviewMouseLeftButtonUp(e);
var Item = (e.OriginalSource as DependencyObject).GetVisualParent <TreeViewItem>();
if (TreeViewExtensions.GetSelectionMode(this) == TreeViewSelectionMode.Extended && Item == SelectedItemOnMouseUp)
{
this.SelectItems(Item);
}
}
/// <summary>
///
/// </summary>
protected override void OnPreviewMouseLeftButtonDown(MouseButtonEventArgs e)
{
base.OnPreviewMouseLeftButtonDown(e);
var Item = (e.OriginalSource as DependencyObject).GetVisualParent <TreeViewItem>();
if (TreeViewExtensions.GetSelectionMode(this) == TreeViewSelectionMode.Extended && Item != null && Item.IsFocused)
{
OnGotFocus(this, e);
}
}
/// <summary>
/// Creates a node that represents the specified contact group.
/// </summary>
private static TreeNode CreateContactGroupNode(ContactGroup contactGroup)
{
TreeNode contactGroupNode = TreeViewExtensions.CreateNode(contactGroup, ImageKey.FolderClosed);
foreach (Contact contact in contactGroup.Contacts)
{
contactGroupNode.Nodes.Add(CreateContactNode(contact));
}
return(contactGroupNode);
}
/// <summary>
/// Set Template for Selected TreeViewItem
/// </summary>
/// <param name="templateName">Template Name</param>
private void SetTemplateForSelectedItem(String templateName)
{
HierarchicalDataTemplate hdt = (HierarchicalDataTemplate)Resources[templateName];
TreeViewItem selectedTreeViewItem =
TreeViewExtensions.GetContainerFromItem(TreeViewMain, selectedNode);
if (selectedTreeViewItem != null)
{
selectedTreeViewItem.HeaderTemplate = hdt;
}
}
/// <summary>
/// Runs the field editor.
/// </summary>
protected void OnRunFieldEditor()
{
var args = ContinuationManager.Current.CurrentArgs as ClientPipelineArgs;
Assert.IsNotNull(args, "args");
if (args.IsPostBack)
{
if (args.HasResult)
{
string result = args.Result;
if (result == "-")
{
return;
}
this.SaveInfo(this.ActiveField.Value);
this.Info.AddRange(this.Metadata.GetAttributesByNames(result.Split('|')));
this.FieldsTree.LoadFromCrmEntry(this.Info);
var field = this.Info.Fields.Where(f => !f.Disabled).Last();
if (field != null)
{
this.ActiveField.Value = field.Name;
TreeViewExtensions.Select(this.FieldsTree, field.Name);
}
this.UpdateSettings(this.ActiveField.Value, true);
this.SaveInfo(this.ActiveField.Value);
AjaxScriptManager.Current.SetInnerHtml(this.TreeViewBorder.ID, this.FieldsTree);
}
}
else
{
this.SaveInfo(this.ActiveField.Value);
var urlString = new UrlString(UIUtil.GetUri("control:Forms.SelectFields"));
var handle = new UrlHandle();
handle["values"] = ParametersUtil.NameValueCollectionToXml(this.GetListOfAvailableFields(), true);
handle["title"] = ResourceManager.Localize("SELECT_FIELDS");
handle["text"] = ResourceManager.Localize("SELECT_FIELDS_DETAILED");
handle.Add(urlString);
SheerResponse.ShowModalDialog(
urlString.ToString(),
string.Empty,
string.Empty,
ResourceManager.Localize("SELECT_FIELDS_FOR_EXPORT"),
true);
args.WaitForPostBack();
}
}
/// <summary>
/// Creates a tree node that represents communication lines.
/// </summary>
private TreeNode CreateLinesNode(CommApp commApp)
{
TreeNode linesNode = TreeViewExtensions.CreateNode(ExtensionPhrases.LinesNode, ImageKey.Lines);
linesNode.ContextMenuStrip = menuControl.LineMenu;
linesNode.Tag = new CommNodeTag(commApp, commApp.AppConfig, CommNodeType.Lines);
foreach (LineConfig lineConfig in commApp.AppConfig.Lines)
{
linesNode.Nodes.Add(CreateLineNode(commApp, lineConfig));
}
return(linesNode);
}
/// <summary>
/// Gets tree nodes to add to the configuration tree.
/// </summary>
public override TreeNode[] GetTreeNodes()
{
TreeNode optionsNode = TreeViewExtensions.CreateNode(
DriverPhrases.OptionsNode, ImageKey.Options, DeviceConfig.DeviceOptions);
itemsNode = TreeViewExtensions.CreateNode(
DriverPhrases.ItemsNode, ImageKey.FolderClosed, DeviceConfig.Items);
foreach (ItemConfig item in DeviceConfig.Items)
{
itemsNode.Nodes.Add(CreateItemNode(item));
}
return(new TreeNode[] { optionsNode, itemsNode });
}
protected override ColumnDefinition OnDefinitionCreated(ContentPresenter child, int index)
{
var result = base.OnDefinitionCreated(child, index);
switch (TreeViewExtensions.GetMode(treeView))
{
case TreeViewModes.Default:
result.Width = new(1, GridUnitType.Star);
break;
case TreeViewModes.Grid:
Bind(TreeViewExtensions.GetColumns(treeView)[index], result);
break;
}
return(result);
}
protected override void OnItemsSourceChanged(OldNew <IEnumerable> input)
{
base.OnItemsSourceChanged(input);
if (TreeViewExtensions.GetMode(treeView) == TreeViewModes.Grid)
{
var columns = TreeViewExtensions.GetColumns(treeView);
if (columns?.Count > 0)
{
columns.ForEach(i =>
{
if (!DependencyObjectExtensions.GetIsVisible(i))
{
Hide(i);
}
});
}
}
}
/// <summary>
/// Creates a node that represents the specified contact.
/// </summary>
private static TreeNode CreateContactNode(Contact contact)
{
TreeNode contactNode = TreeViewExtensions.CreateNode(contact, ImageKey.Contact);
foreach (AddressBookItem contactItem in contact.ContactItems)
{
if (contactItem is PhoneNumber phoneNumber)
{
contactNode.Nodes.Add(CreatePhoneNumberNode(phoneNumber));
}
else if (contactItem is Email email)
{
contactNode.Nodes.Add(CreateEmailNode(email));
}
}
return(contactNode);
}
