public NetworkEdgeWeightsControl(IFeatureDataset dataset, SelectFeatureclassesControl selected)
{
InitializeComponent();
if (dataset != null)
{
_database = dataset.Database as IFeatureDatabase3;
}
if (_database == null)
{
throw new ArgumentException();
}
_selected = selected;
PlugInManager pluginMan = new PlugInManager();
foreach (XmlNode calcNode in pluginMan.GetPluginNodes(Plugins.Type.ISimpleNumberCalculation))
{
ISimpleNumberCalculation calc = pluginMan.CreateInstance(calcNode) as ISimpleNumberCalculation;
if (calc == null)
{
continue;
}
_calculators.Add(calc);
}
}
private void FormDomains_Load(object sender, EventArgs e)
{
PlugInManager compMan = new PlugInManager();
cmbDomains.Items.Add(new DomainItem(null));
cmbDomains.SelectedIndex = 0;
foreach (XmlNode domainNode in compMan.GetPluginNodes(gView.Framework.system.Plugins.Type.IFieldDomain))
{
IFieldDomain fDomain = compMan.CreateInstance(domainNode) as IFieldDomain;
if (fDomain == null)
{
continue;
}
if (_domain != null && fDomain.GetType().Equals(_domain.GetType()))
{
cmbDomains.Items.Add(new DomainItem(_domain));
cmbDomains.SelectedIndex = cmbDomains.Items.Count - 1;
}
else
{
cmbDomains.Items.Add(new DomainItem(fDomain));
}
}
}
public AdditionalFieldsControl()
{
InitializeComponent();
PlugInManager compMan = new PlugInManager();
var autoFields = compMan.GetPlugins(Plugins.Type.IAutoField);
if (autoFields != null)
{
tablePanel.RowCount = autoFields.Count();
tablePanel.Height = autoFields.Count() * 25;
tablePanel.Resize += new EventHandler(tablePanel_Resize);
int row = 0;
foreach (var compType in autoFields)
{
IAutoField aField = compMan.CreateInstance <IAutoField>(compType);
if (aField == null)
{
continue;
}
TextBox box = new TextBox();
AutoFieldCheckBox checkBox = new AutoFieldCheckBox(aField, box);
box.Text = aField.AutoFieldPrimayName;
tablePanel.Controls.Add(checkBox, 0, row);
tablePanel.Controls.Add(box, 1, row++);
}
}
}
public FormExplorerOptions(IMapDocument document)
{
InitializeComponent();
_document = document;
PlugInManager compMan = new PlugInManager();
foreach (XmlNode pageNode in compMan.GetPluginNodes(Plugins.Type.IExplorerOptionPage))
{
IExplorerOptionPage page = compMan.CreateInstance(pageNode) as IExplorerOptionPage;
if (page == null)
{
continue;
}
Panel pagePanel = page.OptionPage();
if (pagePanel == null)
{
continue;
}
TabPage tabPage = new TabPage(page.Title);
tabPage.Controls.Add(pagePanel);
if (page.Image != null)
{
imageList1.Images.Add(page.Image);
tabPage.ImageIndex = imageList1.Images.Count - 1;
}
tabControl.TabPages.Add(tabPage);
_optionPages.Add(page);
}
}
public void Init(int port)
{
_serverConfig = MapServerConfig.ServerByPort(port);
if (_interpreters.Keys.Count == 0)
{
List <IServiceRequestInterpreter> interpreters = new List <IServiceRequestInterpreter>();
PlugInManager compMan = new PlugInManager();
foreach (XmlNode interpreterNode in compMan.GetPluginNodes(Plugins.Type.IServiceRequestInterpreter))
{
IServiceRequestInterpreter interpreter = compMan.CreateInstance(interpreterNode) as IServiceRequestInterpreter;
if (interpreter == null)
{
continue;
}
interpreters.Add(interpreter);
}
foreach (IServiceRequestInterpreter interpreter in interpreters)
{
string guid = PlugInManager.PlugInID(interpreter).ToString().ToLower();
string name = interpreter.IntentityName.ToLower();
if (_interpreters.ContainsKey(guid) || _interpreters.ContainsKey(name))
{
continue;
}
_interpreters.Add(guid, interpreter);
if (!String.IsNullOrEmpty(name))
{
_interpreters.Add(name, interpreter);
}
}
}
}
private void tree_NodeSelected(System.Windows.Forms.TreeNode node)
{
if (_toolStripAddress == null) return;
if (node is ExplorerObjectNode && ((ExplorerObjectNode)node).ExplorerObject != null)
{
RemovePathButtons();
IExplorerObject pathObject = ((ExplorerObjectNode)node).ExplorerObject;
while (pathObject != null)
{
if (pathObject is IExplorerParentObject)
_toolStripAddress.Items.Insert(0, new SubPathParentToolStripItem(this, (IExplorerParentObject)pathObject));
SubPathToolStripItem item = new SubPathToolStripItem(pathObject);
item.Click += new EventHandler(SubPathItem_Click);
_toolStripAddress.Items.Insert(0, item);
pathObject = pathObject.ParentExplorerObject;
}
_selected.Clear();
_selected.Add(_exObject = ((ExplorerObjectNode)node).ExplorerObject);
ViewTabPages(_exObject);
if (_createNewRibbonGroupBox != null)
{
RemoveCreateNewButtons();
PlugInManager compMan = new PlugInManager();
foreach (XmlNode compNode in compMan.GetPluginNodes(Plugins.Type.IExplorerObject))
{
IExplorerObject ex = compMan.CreateInstance(compNode) as IExplorerObject;
if (ex is IExplorerObjectCreatable)
{
if (!((IExplorerObjectCreatable)ex).CanCreate(_exObject)) continue;
//if (_toolStripCreateNew.Items.Count == 0)
//{
// _toolStripCreateNew.Items.Add(new System.Windows.Forms.ToolStripLabel(gView.Framework.Globalisation.LocalizedResources.GetResString("Create.New", "Create new") + ":"));
//}
CreateNewToolStripItem createNewItem = new CreateNewToolStripItem(ex);
createNewItem.Click += createNewItem_Click;
_createNewRibbonGroupBox.Items.Add(createNewItem);
}
}
if (_createNewRibbonGroupBox.Items.Count > 0)
_createNewRibbonGroupBox.Visibility = Visibility.Visible;
}
}
else
{
RemovePathButtons();
ViewTabPages(null);
}
ValidateButtons();
}
static public void AppendMenuItems(ContextMenuStrip strip, IExplorerObject ExplorerObject)
{
if (ExplorerObject == null)
{
return;
}
Guid ExplorerObjectGUID = PlugInManager.PlugInID(ExplorerObject);
PlugInManager compManager = new PlugInManager();
var commands = compManager.GetPlugins(Plugins.Type.IExplorerCommand);
if (commands == null)
{
return;
}
foreach (var commandType in commands)
{
try
{
IExplorerCommand command = compManager.CreateInstance <IExplorerCommand>(commandType);
if (command == null ||
(command.ExplorerObjectGUID != ExplorerObjectGUID && command.ExplorerObjectGUID != KnownExplorerObjectIDs.Any))
{
continue;
}
foreach (XmlNode node in command.CommandDefs)
{
if (node.Attributes["name"] == null)
{
continue;
}
ToolStripItem item = new CommandToolStripItem(ExplorerObject, node);
item.Click += new EventHandler(CommandItem_Click);
if (strip.Items.Count == 0)
{
strip.Items.Add(new ToolStripSeparator());
}
strip.Items.Add(item);
}
}
catch
{
}
}
}
async virtual public Task WriteMetadata(IPersistStream stream)
{
PlugInManager plugins = new PlugInManager();
if (_providers != null)
{
foreach (IMetadataProvider provider in _providers)
{
if (provider == null)
{
continue;
}
// mit ApplyTo noch einmal das this Objekt auf den Provider
// setzen, damit beim speichern immer das aktuelle Object gesetzt wird...
await provider.ApplyTo(this);
stream.Save("IMetadataProvider", provider);
}
}
else
{
_providers = new ConcurrentBag <IMetadataProvider>();
}
foreach (Type providerType in plugins.GetPlugins(typeof(IMetadataProvider)))
{
IMetadataProvider provider = plugins.CreateInstance(providerType) as IMetadataProvider;
if (provider == null)
{
continue;
}
// nach bereits vorhanden suchen...
IMetadataProvider provider2 = this.MetadataProvider(PlugInManager.PlugInID(provider));
if (provider2 != null)
{
continue;
}
if (await provider.ApplyTo(this))
{
stream.Save("IMetadataProvider", provider);
_providers.Add(provider);
}
}
}
public override void Refresh()
{
base.Refresh();
PlugInManager compMan = new PlugInManager();
foreach (XmlNode compNode in compMan.GetPluginNodes(Plugins.Type.IExplorerObject))
{
IExplorerObject exObject = compMan.CreateInstance(compNode) as IExplorerObject;
if (!(exObject is IOgcGroupExplorerObject))
{
continue;
}
base.AddChildObject(exObject);
}
}
private void MakeGUI()
{
cmbSymbolTypes.Items.Clear();
if (PlugInManager.IsPlugin(_symbol))
{
PlugInManager compManager = new PlugInManager();
foreach (var symbolType in compManager.GetPlugins(Plugins.Type.ISymbol))
{
ISymbol symbol = compManager.CreateInstance <ISymbol>(symbolType);
if (symbol is SymbolCollection)
{
continue;
}
if (_symbol.GetType().Equals(symbol.GetType()))
{
symbol = _symbol;
}
if (_symbol is IPointSymbol && symbol is IPointSymbol)
{
cmbSymbolTypes.Items.Add(new SymbolItem(symbol));
}
if (_symbol is ILineSymbol && symbol is ILineSymbol)
{
cmbSymbolTypes.Items.Add(new SymbolItem(symbol));
}
if (_symbol is IFillSymbol && symbol is IFillSymbol)
{
cmbSymbolTypes.Items.Add(new SymbolItem(symbol));
}
if (_symbol is ITextSymbol && symbol is ITextSymbol)
{
((ITextSymbol)symbol).Text = "Label";
cmbSymbolTypes.Items.Add(new SymbolItem(symbol));
}
if (_symbol.GetType().Equals(symbol.GetType()) &&
cmbSymbolTypes.Items.Count > 0)
{
cmbSymbolTypes.SelectedItem = cmbSymbolTypes.Items[cmbSymbolTypes.Items.Count - 1];
}
}
}
}
private void FormAddDataset_Load(object sender, System.EventArgs e)
{
//if(_map==null) this.Close();
listView1.Items.Clear();
PlugInManager compManager = new PlugInManager();
foreach (var type in compManager.GetPlugins(Plugins.Type.IDataset))
{
IDataset dataset = compManager.CreateInstance <IDataset>(type);
if (dataset == null)
{
continue;
}
listView1.Items.Add(new DatasetProviderItem(dataset));
}
}
async public Task <T> LoadPluginAsync <T>(string key, T unknownPlugin = default(T))
where T : IPersistableLoadAsync
{
if (_parent == null)
{
return(default(T));
}
XmlNode xmlnode = _parent.Next(key);
if (xmlnode == null)
{
return(default(T));
}
if (xmlnode.Attributes["GUID"] != null)
{
PlugInManager compManager = new PlugInManager();
T comp = (T)compManager.CreateInstance(new Guid(xmlnode.Attributes["GUID"].Value));
if (comp == null)
{
if (unknownPlugin is IErrorMessage)
{
((IErrorMessage)unknownPlugin).LastErrorMessage = "Unknown plugin type: " + xmlnode.Attributes["GUID"].Value;
}
return(unknownPlugin);
}
//if (comp is IPersistableLoad)
{
XmlNodePlus parent = _parent;
_parent = new XmlNodePlus(xmlnode, _parent.NumberFormat);
//((IPersistable)comp).Load(this);
await comp.LoadAsync(this);
_parent = parent;
}
return(comp);
}
return(unknownPlugin);
}
async public override Task <bool> Refresh()
{
await base.Refresh();
PlugInManager compMan = new PlugInManager();
foreach (var compType in compMan.GetPlugins(Plugins.Type.IExplorerObject))
{
IExplorerObject exObject = compMan.CreateInstance <IExplorerObject>(compType);
if (!(exObject is IOgcGroupExplorerObject))
{
continue;
}
base.AddChildObject(exObject);
}
return(true);
}
async public Task <IExplorerObject> DeserializeExplorerObject(Guid guid, string FullName)
{
IExplorerObject cached = GetExObjectFromCache(FullName);
if (cached != null)
{
return(cached);
}
PlugInManager compManager = new PlugInManager();
object obj = compManager.CreateInstance(guid);
if (!(obj is ISerializableExplorerObject))
{
return(null);
}
return(await((ISerializableExplorerObject)obj).CreateInstanceByFullName(FullName, this));
}
async public override Task <bool> Refresh()
{
await base.Refresh();
string[] drives = System.IO.Directory.GetLogicalDrives();
foreach (string drive in drives)
{
System.IO.DriveInfo info = new System.IO.DriveInfo(drive);
DriveObject exObject = new DriveObject(this, info.Name.Replace("\\", ""), (uint)info.DriveType);
base.AddChildObject(exObject);
}
ConfigConnections configStream = new ConfigConnections("directories");
Dictionary <string, string> networkDirectories = configStream.Connections;
if (networkDirectories != null)
{
foreach (string dir in networkDirectories.Keys)
{
MappedDriveObject exObject = new MappedDriveObject(this, networkDirectories[dir]);
base.AddChildObject(exObject);
}
}
PlugInManager compMan = new PlugInManager();
foreach (var exObjectType in compMan.GetPlugins(Plugins.Type.IExplorerObject))
{
var exObject = compMan.CreateInstance <IExplorerObject>(exObjectType);
if (!(exObject is IExplorerGroupObject))
{
continue;
}
base.AddChildObject(exObject);
}
return(true);
}
public MapServerConnectionExplorerObject(IExplorerObject parent)
: base(parent, null, 0)
{
List <ToolStripItem> contextItems = new List <ToolStripItem>();
ToolStripMenuItem importItem = new ToolStripMenuItem(LocalizedResources.GetResString("Menu.Import", "Import"));
contextItems.Add(importItem);
ToolStripMenuItem newService = new ToolStripMenuItem(LocalizedResources.GetResString("Menu.NewServiceFromMap", "New Service From gView Map..."));
newService.Click += new EventHandler(newService_Click);
newService.Image = (new MapServiceIcon()).Image;
importItem.DropDownItems.Add(newService);
//ToolStripMenuItem newServiceColl = new ToolStripMenuItem("New Map Service Collection ...");
//newServiceColl.Click += new EventHandler(newServiceColl_Click);
//importItem.DropDownItems.Add(newServiceColl);
PlugInManager compMan = new PlugInManager();
foreach (Type serviceableType in compMan
.GetPlugins(Plugins.Type.IServiceableDataset))
{
IServiceableDataset ds = compMan.CreateInstance(serviceableType) as IServiceableDataset;
if (ds == null)
{
return;
}
if (importItem.DropDownItems.Count == 1)
{
importItem.DropDownItems.Add(new ToolStripSeparator());
}
ToolStripItem item = new ServiceableDatasetItem(this, ds);
item.Image = (new MapServiceIcon2()).Image;
importItem.DropDownItems.Add(item);
}
_contextItems = contextItems.ToArray();
}
private void btnAdd_Click(object sender, System.EventArgs e)
{
if (_selectedSymbol == null)
{
return;
}
if (PlugInManager.IsPlugin(_selectedSymbol))
{
PlugInManager comMan = new PlugInManager();
ISymbol newSymbol = (ISymbol)comMan.CreateInstance(PlugInManager.PlugInID(_selectedSymbol));
if (newSymbol != null)
{
AddSymbol(newSymbol);
}
if (SelectedSymbolChanged != null)
{
SelectedSymbolChanged(_selectedSymbol);
}
}
}
public void Content_DragEnter(DragEventArgs e, IUserData userdata)
{
PlugInManager compMan = new PlugInManager();
bool found = false;
foreach (XmlNode dbNode in compMan.GetPluginNodes(Plugins.Type.IFileFeatureDatabase))
{
IFileFeatureDatabase db = compMan.CreateInstance(dbNode) as IFileFeatureDatabase;
if (db == null)
{
continue;
}
found = true;
}
if (!found)
{
return;
}
foreach (string format in e.Data.GetFormats())
{
object ob = e.Data.GetData(format);
if (ob is List <IExplorerObjectSerialization> )
{
foreach (IExplorerObjectSerialization ser in (List <IExplorerObjectSerialization>)ob)
{
if (ser.ObjectTypes.Contains(typeof(IFeatureDataset)) ||
ser.ObjectTypes.Contains(typeof(IFeatureClass)))
{
e.Effect = DragDropEffects.Copy;
return;
}
}
}
}
}
virtual public void WriteMetadata(IPersistStream stream)
{
PlugInManager plugins = new PlugInManager();
if (_providers != null)
{
foreach (IMetadataProvider provider in _providers)
{
if (provider == null) continue;
// mit ApplyTo noch einmal das this Objekt auf den Provider
// setzen, damit beim speichern immer das aktuelle Object gesetzt wird...
provider.ApplyTo(this);
stream.Save("IMetadataProvider", provider);
}
}
else
{
_providers = new List<IMetadataProvider>();
}
foreach (XmlNode providerNode in plugins.GetPluginNodes(Plugins.Type.IMetadataProvider))
{
IMetadataProvider provider = plugins.CreateInstance(providerNode) as IMetadataProvider;
if (provider == null) continue;
// nach bereits vorhanden suchen...
IMetadataProvider provider2 = this.MetadataProvider(PlugInManager.PlugInID(provider));
if (provider2 != null)
continue;
if (provider.ApplyTo(this))
{
stream.Save("IMetadataProvider", provider);
_providers.Add(provider);
}
}
}
public FormGeoProcessor()
{
InitializeComponent();
PlugInManager compMan = new PlugInManager();
foreach (XmlNode activityNode in compMan.GetPluginNodes(Plugins.Type.IActivity))
{
IActivity activity = compMan.CreateInstance(activityNode) as IActivity;
if (activity == null)
{
continue;
}
CategoryNode catNode = TreeCategoryNode(activity.CategoryName);
catNode.Nodes.Add(new ActivityNode(activity));
}
if (tvActivity.Nodes.Count > 0)
{
tvActivity.Nodes[0].Expand();
}
}
private void FillFormatList()
{
PlugInManager compMan = new PlugInManager();
foreach (var dsType in compMan.GetPlugins(Plugins.Type.IDataset))
{
IRasterFileDataset rds = compMan.CreateInstance <IDataset>(dsType) as IRasterFileDataset;
if (rds == null)
{
continue;
}
foreach (string format in rds.SupportedFileFilter.Split('|'))
{
if (format == String.Empty)
{
continue;
}
int priority = rds.SupportsFormat(format.Replace("*", ""));
//FormatListItem item = FindFormatItem(format);
//if (item != null)
//{
// if (item.Priority < priority)
// {
// item.Provider = rds.ToString();
// item.Priority = priority;
// }
//}
//else
//{
// lstFormats.Items.Add(new FormatListItem(format, rds.ToString(), priority));
//}
lstFormats.Items.Add(new FormatListItem(format, rds.ToString(), priority, PlugInManager.PlugInID(rds)));
}
}
}
public void OnCreate(object hook)
{
if (hook is IMapDocument)
{
_doc = (IMapDocument)hook;
_module = Module.GetModule(_doc);
PlugInManager pluginMan = new PlugInManager();
foreach (XmlNode tracerNode in pluginMan.GetPluginNodes(gView.Framework.system.Plugins.Type.INetworkTracer))
{
INetworkTracer tracer = pluginMan.CreateInstance(tracerNode) as INetworkTracer;
if (tracer == null)
{
continue;
}
_combo.Items.Add(new NetworkTracerItem(tracer));
}
if (_combo.Items.Count > 0)
{
_combo.SelectedIndex = 0;
}
}
}
public void OnShowControl(object hook)
{
if (hook is IMapDocument)
{
tabControl.TabPages.Clear();
_document = (IMapDocument)hook;
PlugInManager compMan = new PlugInManager();
foreach (var pageType in compMan.GetPlugins(gView.Framework.system.Plugins.Type.IMapOptionPage))
{
IMapOptionPage page = compMan.CreateInstance <IMapOptionPage>(pageType);
if (page == null)
{
continue;
}
Panel pagePanel = page.OptionPage(_document);
if (pagePanel == null)
{
continue;
}
TabPage tabPage = new TabPage(page.Title);
tabPage.Controls.Add(pagePanel);
if (page.Image != null)
{
imageList1.Images.Add(page.Image);
tabPage.ImageIndex = imageList1.Images.Count - 1;
}
tabControl.TabPages.Add(tabPage);
_optionPages.Add(page);
}
}
}
public object Load(string key, object defValue, object objectInstance)
{
if (_parent == null)
{
return(null);
}
XmlNode xmlnode = _parent.Next(key);
if (xmlnode == null)
{
return(defValue);
}
if (xmlnode.Attributes["GUID"] != null)
{
PlugInManager compManager = new PlugInManager();
object comp = compManager.CreateInstance(new Guid(xmlnode.Attributes["GUID"].Value));
if (comp == null)
{
return(defValue);
}
if (comp is IPersistable)
{
XmlNodePlus parent = _parent;
_parent = new XmlNodePlus(xmlnode, _parent.NumberFormat);
((IPersistable)comp).Load(this);
_parent = parent;
}
else if (comp is IPersistableLoadAsync)
{
throw new Exception("Can't laod async in this context (" + comp.GetType().ToString() + ")");
}
return(comp);
}
if (xmlnode.Attributes["type"] == null)
{
if (objectInstance is IPersistable)
{
XmlNodePlus parent = _parent;
_parent = new XmlNodePlus(xmlnode, _parent.NumberFormat);
((IPersistable)objectInstance).Load(this);
_parent = parent;
return(objectInstance);
}
else if (objectInstance is IPersistableLoadAsync)
{
throw new Exception("Can't laod async in this context (" + objectInstance.GetType().ToString() + ")");
}
else
{
return(defValue);
}
}
try
{
if (xmlnode.Attributes["type"].Value != "System.String")
{
Type type = global::System.Type.GetType(xmlnode.Attributes["type"].Value, false, true);
object obj = Activator.CreateInstance(type);
if (obj == null)
{
return(defValue);
}
if (obj is XmlStreamObject)
{
ApplyXmlStreamObjectAttributes(xmlnode, (XmlStreamObject)obj);
if (obj is XmlStreamOption)
{
XmlNodePlus parent = _parent;
_parent = new XmlNodePlus(xmlnode, _parent.NumberFormat);
List <object> options = new List <object>();
object option;
while ((option = Load("Option", null)) != null)
{
options.Add(option);
}
((XmlStreamOption)obj).Options = options.ToArray();
((XmlStreamOption)obj).Value = Load("Value", null);
_parent = parent;
}
else if (obj is XmlStreamStringArray)
{
XmlNodePlus parent = _parent;
_parent = new XmlNodePlus(xmlnode, _parent.NumberFormat);
List <string> values = new List <string>();
object Value;
while ((Value = Load("Value", null)) != null)
{
values.Add(Value.ToString());
}
((XmlStreamObject)obj).Value = values.ToArray();
_parent = parent;
}
else
{
XmlNodePlus parent = _parent;
_parent = new XmlNodePlus(xmlnode, _parent.NumberFormat);
((XmlStreamObject)obj).Value = Load("Value", null);
_parent = parent;
}
return(obj);
}
obj = Convert.ChangeType(xmlnode.Attributes["value"].Value, type, _parent.NumberFormat);
return(obj);
}
else
{
string v = xmlnode.Attributes["value"].Value;
if (xmlnode.Attributes["encryption_type"] != null)
{
switch (xmlnode.Attributes["encryption_type"].Value)
{
case "1":
v = Crypto.Decrypt(v, "3f9932916f9746e1a3df048cc70dd30a");
break;
}
}
return(v);
}
}
catch/*(Exception ex)*/
{
return(defValue);
}
}
private bool InsertImage(IFeatureUpdater fdb, IFeatureClass rasterFC, FileInfo fi, Dictionary <string, Guid> providers)
{
if (!_cancelTracker.Continue)
{
_errMsg = "Canceled by user...";
return(false);
}
if (ReportAction != null)
{
ReportAction(this, "Insert Image: " + fi.FullName);
}
if (ReportProgress != null)
{
ReportProgress(this, 1);
}
System.Drawing.Imaging.ImageFormat format = System.Drawing.Imaging.ImageFormat.Jpeg;
switch (fi.Extension.ToLower())
{
case ".png":
format = System.Drawing.Imaging.ImageFormat.Png;
break;
case ".tif":
case ".tiff":
format = System.Drawing.Imaging.ImageFormat.Tiff;
break;
}
#region RasterFileDataset bestimmen
List <IRasterFileDataset> rFileDatasets = new List <IRasterFileDataset>();
IRasterFileDataset rFileDataset = null;
IRasterLayer rasterLayer = null;
PlugInManager compMan = new PlugInManager();
foreach (XmlNode ds in compMan.GetPluginNodes(Plugins.Type.IDataset))
{
IRasterFileDataset rds = compMan.CreateInstance(ds) as IRasterFileDataset;
if (rds == null)
{
continue;
}
if (rds.SupportsFormat(fi.Extension) < 0)
{
continue;
}
if (providers != null && providers.ContainsKey(fi.Extension.ToLower()))
{
if (!providers[fi.Extension.ToLower()].Equals(PlugInManager.PlugInID(rds)))
{
continue;
}
}
rFileDatasets.Add(rds);
}
if (rFileDatasets.Count == 0)
{
_errMsg = "No Rasterfile Provider for " + fi.Extension;
return(false);
}
// RasterFileDataset nach priorität sortieren
rFileDatasets.Sort(new RasterFileDatasetComparer(fi.Extension));
// RasterFileDataset suchen, mit dem sich Bild öffnen läßt
foreach (IRasterFileDataset rfd in rFileDatasets)
{
rfd.AddRasterFile(fi.FullName);
if (rfd.Elements.Count == 0)
{
//Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster File...");
continue;
}
IDatasetElement element = rfd.Elements[0];
if (!(element is IRasterLayer))
{
//Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster Layer...");
rFileDataset.Dispose();
continue;
}
// gefunden...
rasterLayer = (IRasterLayer)element;
rFileDataset = rfd;
break;
}
if (rasterLayer == null || rFileDataset == null)
{
Console.WriteLine(_errMsg = fi.FullName + " is not a valid Raster Layer...");
return(false);
}
#endregion
FileInfo fiWorld = null;
double cellX = 1;
double cellY = 1;
IRasterFile rasterFile = null;
if (rasterLayer is IRasterFile)
{
rasterFile = (IRasterFile)rasterLayer;
}
if (rasterLayer.RasterClass != null)
{
if (rasterLayer.RasterClass is IRasterFile &&
((IRasterFile)rasterLayer.RasterClass).WorldFile != null)
{
rasterFile = (IRasterFile)rasterLayer.RasterClass;
}
else
{
IRasterClass c = (IRasterClass)rasterLayer.RasterClass;
cellX = Math.Sqrt(c.dx1 * c.dx1 + c.dx2 * c.dx2);
cellY = Math.Sqrt(c.dy1 * c.dy1 + c.dy2 * c.dy2);
}
}
if (rasterFile != null)
{
try
{
IRasterWorldFile world = rasterFile.WorldFile;
if (world != null)
{
if (!world.isGeoReferenced)
{
if (handleNonGeorefAsError)
{
_errMsg = "Can't add non georeferenced images: " + fi.FullName;
return(false);
}
else
{
return(true);
}
}
cellX = Math.Sqrt(world.dx_X * world.dx_X + world.dx_Y * world.dx_Y);
cellY = Math.Sqrt(world.dy_X * world.dy_X + world.dy_Y * world.dy_Y);
fiWorld = new FileInfo(rasterFile.WorldFile.Filename);
if (!fiWorld.Exists)
{
fiWorld = null;
}
}
}
catch
{
fiWorld = null;
}
}
#region Check if already Exits
//
// Suchen, ob Image mit gleichen Pfad schon vorhanden ist, wenn ja
// nur weitermachen, wenn sich das änderungsdatum unterscheidet...
//
QueryFilter filter = new QueryFilter();
filter.AddField("FDB_OID");
filter.AddField("PATH");
filter.AddField("LAST_MODIFIED");
filter.AddField("PATH2");
filter.AddField("LAST_MODIFIED2");
string fullName = fi.FullName.Replace(@"\", @"\\");
if (_fdb is AccessFDB)
{
filter.WhereClause = ((AccessFDB)_fdb).DbColName("PATH") + "='" + fullName + "'";
}
else
{
filter.WhereClause = "PATH='" + fullName + "'";
}
int deleteOID = -1;
using (IFeatureCursor cursor = rasterFC.GetFeatures(filter))
{
IFeature existingFeature = cursor.NextFeature;
if (existingFeature != null)
{
DateTime dt1 = (DateTime)existingFeature["LAST_MODIFIED"];
if (Math.Abs(((TimeSpan)(dt1 - fi.LastWriteTimeUtc)).TotalSeconds) > 1.0)
{
deleteOID = existingFeature.OID;
}
else if (fiWorld != null &&
existingFeature["PATH2"] != System.DBNull.Value &&
existingFeature["PATH2"].ToString() != String.Empty)
{
DateTime dt2 = (DateTime)existingFeature["LAST_MODIFIED2"];
if (existingFeature["PATH2"].ToString().ToLower() != fiWorld.FullName.ToLower() ||
Math.Abs(((TimeSpan)(dt2 - fiWorld.LastWriteTimeUtc)).TotalSeconds) > 1.0)
{
deleteOID = existingFeature.OID;
}
}
if (deleteOID == -1)
{
Console.Write(".");
//Console.WriteLine(fi.FullName + " already exists...");
return(true);
}
}
}
if (deleteOID != -1)
{
if (!fdb.Delete(rasterFC, deleteOID))
{
Console.WriteLine(_errMsg = "Can't delete old record " + fi.FullName + "\n" + fdb.lastErrorMsg);
return(false);
}
}
//
///////////////////////////////////////////////////////////////////
//
#endregion
Feature feature = new Feature();
feature.Shape = rasterLayer.RasterClass.Polygon;
feature.Fields.Add(new FieldValue("PATH", fi.FullName));
feature.Fields.Add(new FieldValue("LAST_MODIFIED", fi.LastWriteTimeUtc));
if (fiWorld != null)
{
feature.Fields.Add(new FieldValue("PATH2", fiWorld.FullName));
feature.Fields.Add(new FieldValue("LAST_MODIFIED2", fiWorld.LastWriteTimeUtc));
}
else
{
feature.Fields.Add(new FieldValue("PATH2", ""));
}
feature.Fields.Add(new FieldValue("RF_PROVIDER", PlugInManager.PlugInID(rFileDataset).ToString()));
feature.Fields.Add(new FieldValue("MANAGED", _managed && (rasterLayer is IBitmap)));
feature.Fields.Add(new FieldValue("FORMAT", fi.Extension.Replace(".", "")));
feature.Fields.Add(new FieldValue("CELLX", cellX));
feature.Fields.Add(new FieldValue("CELLY", cellY));
feature.Fields.Add(new FieldValue("LEVELS", (_managed) ? Math.Max(_levels, 1) : 0));
if (!fdb.Insert(rasterFC, feature))
{
Console.WriteLine("\nERROR@" + fi.FullName + ": " + fdb.lastErrorMsg);
}
else
{
if (_managed && (rasterLayer is IBitmap) && (fdb is SqlFDB))
{
QueryFilter qfilter = new QueryFilter();
qfilter.SubFields = "FDB_OID";
if (_fdb is AccessFDB)
{
filter.WhereClause = ((AccessFDB)_fdb).DbColName("PATH") + "='" + fi.FullName + "'";
}
else
{
qfilter.WhereClause = "PATH='" + fi.FullName + "'";
}
IFeatureCursor cursor = ((SqlFDB)fdb).Query(rasterFC, qfilter);
if (cursor != null)
{
IFeature feat = cursor.NextFeature;
if (feat != null)
{
InsertImageDatasetBitmap(feat.OID, rasterLayer, _levels, format);
}
cursor.Dispose();
}
}
Console.WriteLine(">" + fi.FullName + " added...");
}
rFileDataset.Dispose();
return(true);
}
private void gridFcs_CellValueChanged(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex < 0 || lstWeights.SelectedItems.Count != 1)
{
return;
}
IGraphWeight weight = ((WeightListViewItem)lstWeights.SelectedItems[0]).GraphWeight;
int fcId = Convert.ToInt32(gridFcs.Rows[e.RowIndex].Cells[0].Value);
string fieldName = (string)((DataGridViewComboBoxCell)gridFcs.Rows[e.RowIndex].Cells[2]).Value;
IGraphWeightFeatureClass gwfc = weight.FeatureClasses[fcId];
if (gwfc == null)
{
gwfc = new GraphWeightFeatureClass(fcId, fieldName);
weight.FeatureClasses[fcId] = gwfc;
}
if (e.ColumnIndex == 2)
{
if (fieldName == null || fieldName == "<none>")
{
((GraphWeightFeatureClass)gwfc).FieldName = String.Empty;
}
else
{
((GraphWeightFeatureClass)gwfc).FieldName = fieldName;
}
}
if (e.ColumnIndex == 3)
{
if (gwfc.SimpleNumberCalculation != null &&
gwfc.SimpleNumberCalculation.Name == gridFcs.Rows[e.RowIndex].Cells[3].Value.ToString())
{
}
else
{
if (gridFcs.Rows[e.RowIndex].Cells[3].Value.ToString() == "<none>")
{
((GraphWeightFeatureClass)gwfc).SimpleNumberCalculation = null;
}
foreach (ISimpleNumberCalculation calc in _calculators)
{
if (calc.Name == gridFcs.Rows[e.RowIndex].Cells[3].Value.ToString())
{
PlugInManager pMan = new PlugInManager();
((GraphWeightFeatureClass)gwfc).SimpleNumberCalculation = pMan.CreateInstance(PlugInManager.PlugInID(calc)) as ISimpleNumberCalculation;
}
}
}
}
}
static void Main(string[] args)
{
System.Net.ServicePointManager.DefaultConnectionLimit = 256;
//System.Net.ServicePointManager.MaxServicePoints = 256;
System.Net.ServicePointManager.CertificatePolicy = new gView.Framework.Web.SimpleHttpsPolicy();
gView.Framework.system.gViewEnvironment.UserInteractive = false;
//int x = 0;
//x = 1 / x;
try
{
//Thread thread = new Thread(new ThreadStart(StartThread2));
//thread.Start();
//gView.Framework.system.SystemVariables.ApplicationDirectory = gView.Framework.system.SystemVariables.RegistryApplicationDirectory;
Logger.Log(loggingMethod.request, "Service EXE started...");
bool console = false;
int port = -1;
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "-c")
{
console = true;
}
if (args[i] == "-port")
{
port = int.Parse(args[i + 1]);
}
}
//port = 8001;
//console = true;
Logger.Log(loggingMethod.request, "Current Directory: " + System.Environment.CurrentDirectory);
//Logger.Log(loggingMethod.request, "Check license...");
//myLicense = new License(false);
//Logger.Log(loggingMethod.request, "License Info********");
//Logger.Log(loggingMethod.request, "ProductID: " + myLicense.ProductID);
//Logger.Log(loggingMethod.request, "InstallationDate: " + SystemVariables.InstallationTime.ToShortDateString() + " " + SystemVariables.InstallationTime.ToLongTimeString());
//Logger.Log(loggingMethod.request, "LicenseFile: " + myLicense.LicenseFile);
//Logger.Log(loggingMethod.request, "LicenseFileExists: " + myLicense.LicenseFileExists.ToString());
//if (myLicense.LicenseComponents != null)
//{
// Logger.Log(loggingMethod.request, "Components:");
// foreach (string component in myLicense.LicenseComponents)
// Logger.Log(loggingMethod.request, " " + component);
//}
//LicenseTypes licType = IMS.myLicense.ComponentLicenseType("gview.Server;gview.PersonalMapServer");
//if (licType == LicenseTypes.Unknown ||
// licType == LicenseTypes.Expired)
//{
// Logger.Log(loggingMethod.error, "Server is not licensed...");
// return;
//}
//Logger.Log(loggingMethod.request, "********************");
// Interpreter suchen...
Logger.Log(loggingMethod.request, "Register request interpreters...");
mapServer = new MapServer(port);
/*
* switch (mapServer.LicType)
* {
* case MapServer.ServerLicType.Unknown:
* Logger.Log(loggingMethod.error, "Unkown License");
* if (console)
* {
* Console.WriteLine("Unkown License...");
#if(DEBUG)
* Console.ReadLine();
#endif
* }
* return;
* case MapServer.ServerLicType.Express:
* case MapServer.ServerLicType.Private:
* System.Diagnostics.Process[] procs = System.Diagnostics.Process.GetProcessesByName("gview.mapserver");
* if (procs.Length > 1)
* {
* Logger.Log(loggingMethod.error, "Your server license type '" + mapServer.LicType.ToString() + "' allows only one server instance!");
* if (console)
* {
* Console.WriteLine("Your server license type '" + mapServer.LicType.ToString() + "' allows only one server instance!");
#if(DEBUG)
* Console.ReadLine();
#endif
* }
* return;
* }
* break;
* }
* */
PlugInManager compMan = new PlugInManager();
foreach (XmlNode interpreterNode in compMan.GetPluginNodes(Plugins.Type.IServiceRequestInterpreter))
{
IServiceRequestInterpreter interpreter = compMan.CreateInstance(interpreterNode) as IServiceRequestInterpreter;
if (interpreter == null)
{
continue;
}
interpreter.OnCreate(mapServer);
_interpreters.Add(interpreter);
}
try
{
SetConsoleTitle("gView.MapServer.Instance." + port);
}
catch { }
#if (!DEBUG)
if (console)
{
//ImageService service = new ImageService();
//service.Start(args);
Console.WriteLine("Server Instance " + port + " starting...");
ServerProcess process = new ServerProcess(port, false);
Console.WriteLine("Server Instance is listing on port " + port);
Console.ReadLine();
process.Stop();
//service.Stop();
}
else
{
if (port != -1)
{
Console.WriteLine("Start Server On Port: " + port);
ServerProcess process = new ServerProcess(port, true);
}
else
{
System.ServiceProcess.ServiceBase[] ServicesToRun;
ServicesToRun = new System.ServiceProcess.ServiceBase[] { new ImageService() };
System.ServiceProcess.ServiceBase.Run(ServicesToRun);
}
}
#else
port = (port != -1) ? port : 8001;
Console.WriteLine("Server Instance " + port + " starting...");
ServerProcess process = new ServerProcess(port, false);
Console.WriteLine("Server Instance is listing on port " + port);
Console.ReadLine();
Console.WriteLine("Stopping Instance on port " + port);
process.Stop();
#endif
}
catch (Exception ex)
{
Logger.Log(loggingMethod.error, ex.Message);
}
}
static int Main(string[] args)
{
string gmlSource = String.Empty;
string cacheSource = String.Empty;
string cacheTarget = String.Empty;
int jpegQuality = -1, maxlevel = -1;
bool listFilenames = false;
for (int i = 0; i < args.Length - 1; i++)
{
if (args[i] == "-gml")
{
gmlSource = args[++i];
}
if (args[i] == "-cache")
{
cacheSource = args[++i];
}
else if (args[i] == "-target")
{
cacheTarget = args[++i];
}
else if (args[i] == "-jpeg-qual")
{
jpegQuality = int.Parse(args[++i]);
}
else if (args[i] == "-maxlevel")
{
maxlevel = int.Parse(args[++i]);
}
else if (args[i] == "-listfilenames")
{
listFilenames = true;
}
}
if (String.IsNullOrWhiteSpace(gmlSource) || String.IsNullOrWhiteSpace(cacheSource) || String.IsNullOrWhiteSpace(cacheTarget))
{
Console.WriteLine("USAGE:");
Console.WriteLine("gView.Cmd.ClipCompactTilecache.exe -gml <Filename> -cache <cachedirectory> -target <cachetarget>");
Console.WriteLine(" [-jpeg-qual <quality 0..100>] -maxlevel <level>");
Console.WriteLine(" [-listfilenames]");
return(1);
}
PlugInManager compMan = new PlugInManager();
IFeatureDataset gmlDataset = compMan.CreateInstance(new Guid("dbabe7f1-fe46-4731-ab2b-8a324c60554e")) as IFeatureDataset;
gmlDataset.ConnectionString = gmlSource;
gmlDataset.Open();
List <IPolygon> sourcePolygons = new List <IPolygon>();
foreach (var element in gmlDataset.Elements)
{
if (element.Class is IFeatureClass)
{
var fc = (IFeatureClass)element.Class;
using (var cursor = fc.GetFeatures(null))
{
IFeature feature;
while ((feature = cursor.NextFeature) != null)
{
if (feature.Shape is IPolygon)
{
sourcePolygons.Add((IPolygon)feature.Shape);
}
}
}
}
}
if (!listFilenames)
{
Console.WriteLine(sourcePolygons.Count + " polygons found for clipping...");
}
FileInfo configFile = new FileInfo(cacheSource + @"\conf.json");
if (!configFile.Exists)
{
throw new ArgumentException("File " + configFile.FullName + " not exists");
}
#region Image Encoding Parameters
System.Drawing.Imaging.ImageCodecInfo jpgEncoder = GetEncoder(System.Drawing.Imaging.ImageFormat.Jpeg);
// Create an Encoder object based on the GUID
// for the Quality parameter category.
System.Drawing.Imaging.Encoder myEncoder =
System.Drawing.Imaging.Encoder.Quality;
// Create an EncoderParameters object.
// An EncoderParameters object has an array of EncoderParameter
// objects. In this case, there is only one
// EncoderParameter object in the array.
System.Drawing.Imaging.EncoderParameters myEncoderParameters = new System.Drawing.Imaging.EncoderParameters(1);
#endregion
CompactTileConfig cacheConfig = JsonConvert.DeserializeObject <CompactTileConfig>(File.ReadAllText(configFile.FullName));
double dpm = cacheConfig.Dpi / 0.0254;
foreach (var level in cacheConfig.Levels)
{
if (!listFilenames)
{
Console.WriteLine("Level: " + level.Level + " Scale=" + level.Scale);
}
double resolution = (level.Scale / dpm);
double tileWorldWidth = cacheConfig.TileSize[0] * resolution;
double tileWorldHeight = cacheConfig.TileSize[1] * resolution;
var scaleDirectory = new DirectoryInfo(cacheSource + @"\" + ((int)level.Scale).ToString());
if (!scaleDirectory.Exists)
{
continue;
}
foreach (var bundleFile in scaleDirectory.GetFiles("*.tilebundle"))
{
var bundle = new Bundle(bundleFile.FullName);
if (!bundle.Index.Exists)
{
continue;
}
int startRow = bundle.StartRow, startCol = bundle.StartCol;
double bundleWorldWidth = tileWorldWidth * 128D, bundleWorldHeight = tileWorldHeight * 128D;
IPoint bundleLowerLeft = new Point(cacheConfig.Origin[0] + startCol * tileWorldWidth,
cacheConfig.Origin[1] - startRow * tileWorldHeight - bundleWorldHeight);
IEnvelope bundleEnvelope = new Envelope(bundleLowerLeft, new Point(bundleLowerLeft.X + bundleWorldWidth, bundleLowerLeft.Y + bundleWorldHeight));
if (!Intersect(bundleEnvelope, sourcePolygons))
{
continue;
}
if (listFilenames)
{
Console.WriteLine(bundleFile.FullName);
continue;
}
Console.WriteLine("Clip bundle: " + bundleFile.FullName);
var clippedBundleFile = new FileInfo(cacheTarget + @"\" + (int)level.Scale + @"\" + bundleFile.Name);
if (!clippedBundleFile.Directory.Exists)
{
clippedBundleFile.Directory.Create();
}
if (clippedBundleFile.Exists)
{
clippedBundleFile.Delete();
}
var indexBuilder = new CompactTilesIndexBuilder();
int clippedTilePos = 0;
for (int r = 0; r < 128; r++)
{
for (int c = 0; c < 128; c++)
{
int tileLength;
int tilePos = bundle.Index.TilePosition(r, c, out tileLength);
if (tilePos >= 0 && tileLength >= 0)
{
IPoint tileLowerLeft = new Point(cacheConfig.Origin[0] + (startCol + c) * tileWorldWidth,
cacheConfig.Origin[1] - (startRow + r + 1) * tileWorldHeight);
IEnvelope tileEnvelope = new Envelope(tileLowerLeft, new Point(tileLowerLeft.X + tileWorldWidth, tileLowerLeft.Y + tileWorldHeight));
if (!Intersect(tileEnvelope, sourcePolygons))
{
continue;
}
Console.WriteLine("Append tile " + level.Level + "/" + (startRow + r) + "/" + (startCol + c));
byte[] data = bundle.ImageData(tilePos, tileLength);
if (jpegQuality > 0)
{
#region New Jpeg Quality
MemoryStream ms = new MemoryStream(data);
using (System.Drawing.Image image = System.Drawing.Image.FromStream(ms))
{
MemoryStream outputMs = new MemoryStream();
System.Drawing.Imaging.EncoderParameter myEncoderParameter = new System.Drawing.Imaging.EncoderParameter(myEncoder, Convert.ToInt64(jpegQuality));
myEncoderParameters.Param[0] = myEncoderParameter;
image.Save(outputMs, jpgEncoder, myEncoderParameters);
data = outputMs.ToArray();
}
#endregion
}
using (var stream = new FileStream(clippedBundleFile.FullName, FileMode.Append))
{
stream.Write(data, 0, data.Length);
}
indexBuilder.SetValue(r, c, clippedTilePos, data.Length);
clippedTilePos += data.Length;
}
}
}
if (clippedTilePos > 0)
{
indexBuilder.Save(clippedBundleFile.Directory.FullName + @"\" + new FileInfo(bundle.Index.Filename).Name);
}
}
if (maxlevel >= 0 && level.Level >= maxlevel)
{
break;
}
}
return(0);
}
private void MakeMainMenuBar(XmlNode node)
{
if (node == null) return;
backstageTabControl.Items.Clear();
PlugInManager compManager = new PlugInManager();
foreach (XmlNode menu in node.SelectNodes("Menu[@name]"))
{
if (menu.Attributes["name"].Value.ToLower() == "file")
{
foreach (XmlNode menuItem in menu.SelectNodes("MenuItem"))
{
if (menuItem.Attributes["guid"] == null)
{
//backstageTabControl.Items.Add(new Separator());
}
else
{
IExTool tool = (IExTool)compManager.CreateInstance(new Guid(menuItem.Attributes["guid"].Value));
if (tool == null) continue;
tool.OnCreate(_application);
if (tool is IToolControl)
{
Fluent.BackstageTabItem backItem = new Fluent.BackstageTabItem();
backItem.Header = tool.Name;
object control = ((IToolControl)tool).Control;
if (control is System.Windows.Forms.Control)
{
WindowsFormsHost host = WinHostFactory.ToWindowsHost((System.Windows.Forms.Control)control);
backItem.Content = host;
}
else if (control is FrameworkElement)
{
backItem.Content = control;
}
backstageTabControl.Items.Add(backItem);
}
else
{
Items.ToolButton button = new Items.ToolButton(tool);
button.Click += new RoutedEventHandler(ToolButton_Click);
backstageTabControl.Items.Add(button);
}
}
}
}
if (menu.Attributes["name"].Value.ToLower() == "quickaccess")
{
foreach (XmlNode menuItem in menu.SelectNodes("MenuItem"))
{
IExTool tool = compManager.CreateInstance(new Guid(menuItem.Attributes["guid"].Value)) as IExTool;
if (tool == null) continue;
tool.OnCreate(_application);
ToolButton button = new ToolButton((IExTool)tool);
button.Click += new RoutedEventHandler(ToolButton_Click);
ribbon.QuickAccessItems.Add(new Fluent.QuickAccessMenuItem() { Target = button });
}
}
}
}
public MainWindow()
{
try
{
InitializeComponent();
_application = new ExplorerApplication(this);
_application.DockWindowAdded += new DockWindowAddedEvent(_application_DockWindowAdded);
_application.OnShowDockableWindow += new OnShowDockableWindowEvent(_application_OnShowDockableWindow);
#region Windows Forms Control Disign
_toolStripAddress = new System.Windows.Forms.ToolStrip();
_toolStripAddress.Stretch = true;
_toolStripAddress.GripMargin = new System.Windows.Forms.Padding(1);
_toolStripAddress.LayoutStyle = System.Windows.Forms.ToolStripLayoutStyle.Flow;
_toolStripAddress.BackColor = System.Drawing.Color.White;
winFormsHostStripAddress.Child = _toolStripAddress;
#endregion
_tree = new gView.Framework.UI.Dialogs.FormCatalogTree(_application, false);
_tree.NodeSelected += new gView.Framework.UI.Dialogs.FormCatalogTree.NodeClickedEvent(tree_NodeSelected);
_tree.NodeRenamed += new gView.Framework.UI.Dialogs.FormCatalogTree.NodeRenamedEvent(tree_NodeRenamed);
_tree.NodeDeleted += new gView.Framework.UI.Dialogs.FormCatalogTree.NodeDeletedEvent(tree_NodeDeleted);
//winFormsHostExplorerTree.Child = _tree;
PlugInManager compMan = new PlugInManager();
foreach (XmlNode tabNode in compMan.GetPluginNodes(Plugins.Type.IExplorerTabPage))
{
IExplorerTabPage page = (IExplorerTabPage)compMan.CreateInstance(tabNode);
if (page == null || page.Control == null)
continue;
page.OnCreate(_application);
LayoutDocument layoutDoc = new LayoutDocument();
layoutDoc.Title = layoutDoc.ContentId = page.Title;
layoutDoc.CanClose = false;
layoutDoc.CanFloat = false;
layoutDoc.Content = new WindowsFormsHost();
((WindowsFormsHost)layoutDoc.Content).Child = page.Control;
_tabPages.Add(new TabPage(page, layoutDoc));
if (page is gView.Framework.UI.Controls.ContentsList)
{
((gView.Framework.UI.Controls.ContentsList)page).ItemSelected += new gView.Framework.UI.Controls.ContentsList.ItemClickedEvent(ContentsList_ItemSelected);
_content = (gView.Framework.UI.Controls.ContentsList)page;
}
}
explorerDocPane.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(explorerDocPane_PropertyChanged);
anchorPaneRight.Children[0].Hide();
_application.AddDockableWindow(_tree, DockWindowState.left);
try
{
XmlDocument doc = new XmlDocument();
doc.Load("menu.explorer.xml");
MakeMainMenuBar(doc.SelectSingleNode("//Menubar"));
}
catch { }
MakeRibbon();
ValidateButtons();
} catch(Exception ex)
{
System.Windows.MessageBox.Show(ex.Message + "\n" + ex.StackTrace);
}
}
