private void AddView(int i)
{
if (Views == null)
{
Views = new ObservableCollection <ViewModelBase>();
}
switch (i)
{
case 1:
if (!Views.Any(x => x.GetType() == typeof(FirstViewModel)))
{
Views.Add(new FirstViewModel());
}
break;
case 2:
if (!Views.Any(x => x.GetType() == typeof(SecondViewModel)))
{
Views.Add(new SecondViewModel());
}
break;
case 3:
if (!Views.Any(x => x.GetType() == typeof(ThirdViewModel)))
{
Views.Add(new ThirdViewModel());
}
break;
}
OnPropertyChanged("Views");
}
public WindowViewModel(IObjectProvider objectProvider, IWindowFactory windowFactory)
{
_objectProvider = objectProvider;
InterTabClient = new InterTabClient(windowFactory);
_showMenuCommand = new Command(ShowMenu, () => Selected != null && !(Selected.Content is MenuItems));
ShowInGitHubCommand = new Command(() => Process.Start("https://github.com/RolandPheasant"));
var menuController = Views.ToObservableChangeSet()
.Filter(vc => vc.Content is MenuItems)
.Transform(vc => (MenuItems)vc.Content)
.MergeMany(menuItem => menuItem.ItemCreated)
.Subscribe(item =>
{
Views.Add(item);
Selected = item;
});
_cleanUp = Disposable.Create(() =>
{
menuController.Dispose();
foreach (var disposable in Views.Select(vc => vc.Content).OfType <IDisposable>())
{
disposable.Dispose();
}
});
}
private void ExecuteShowHelpPageCommand(Object args)
{
WorkspaceData workspace = new WorkspaceData("", "HelpPageView", null, "About Page", true);
Views.Add(workspace);
SetActiveWorkspace(workspace);
}
/// <summary>
/// Adds an un-parameterized view to the stream.
/// </summary>
/// <param name="namespace">is the view namespace, for example "win" for most data windows</param>
/// <param name="name">is the view name, for example "length" for a length window</param>
/// <returns>stream</returns>
public ProjectedStream AddView(
string @namespace,
string name)
{
Views.Add(View.Create(@namespace, name));
return this;
}
private static void addView(DbSearcher ask, int appId, User user)
{
Views.Add(
key: (user.UserName + appId),
value: (ask.GetAllUserViews(user.Id).ConvertToObjects())
);
}
// Creates a new image view with the given image and
// scales it down if it exceeds a maximum size.
//
// - Parameter image: the image to be displayed in the image view.
// - Returns: A newly created image view with the given image, resized if necessary.
public UIImageView NewImageView(UIImage image)
{
var imageView = new UIImageView()
{
Image = image,
ContentMode = UIViewContentMode.ScaleAspectFit,
UserInteractionEnabled = true
};
var size = image.Size;
var longestSide = (float)Math.Max(size.Width, size.Height);
var maximumLength = 200f;
var scaleFactor = 1f;
// If the given image exceeds `maximumLength`,
// we resize the image view to match that length
// while preserving the original aspect ratio.
if (longestSide > maximumLength)
{
scaleFactor = maximumLength / longestSide;
}
size = new CGSize((float)Math.Round(size.Width * scaleFactor), (float)Math.Round(size.Height * scaleFactor));
imageView.Frame = new CGRect(imageView.Frame.Location, size);
Views.Add(imageView);
View.AddSubview(imageView);
return(imageView);
}
private void loadViews()
{
XmlNodeList views = viewsXml.SelectNodes("/views/view");
foreach (XmlElement viewEl in views)
{
int id = Convert.ToInt32(viewEl.GetAttribute("id"));
XmlView view = new XmlView(id);
XmlElement descriptionEl = (XmlElement)viewEl.SelectSingleNode("description");
if (descriptionEl != null)
{
view.Description = descriptionEl.InnerText;
}
Views.Add(view);
XmlNodeList loops = viewEl.SelectNodes("loop");
foreach (XmlElement loopEl in loops)
{
XmlLoop loop = new XmlLoop();
view.Loops.Add(loop);
XmlNodeList cels = loopEl.SelectNodes("cel");
foreach (XmlElement celEl in cels)
{
int width = Convert.ToInt32(celEl.GetAttribute("width"));
int height = Convert.ToInt32(celEl.GetAttribute("height"));
XmlCel cel = new XmlCel(width, height);
loop.Add(cel);
}
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This method updates the view model data and sends update command back
/// to the solution builder.</summary>
///--------------------------------------------------------------------------------
protected override void OnUpdate()
{
// send update for any updated children
foreach (ViewViewModel item in Views)
{
if (item.IsEdited == true)
{
item.Update();
}
}
// send update for any new children
foreach (ViewViewModel item in ItemsToAdd.OfType <ViewViewModel>())
{
item.Update();
Views.Add(item);
}
ItemsToAdd.Clear();
// send delete for any deleted children
foreach (ViewViewModel item in ItemsToDelete.OfType <ViewViewModel>())
{
item.Delete();
Views.Remove(item);
}
ItemsToDelete.Clear();
// reset modified for children
foreach (ViewViewModel item in Views)
{
item.ResetModified(false);
}
}
//TODO: Abstract this
public void OpenView(HeaderedView headeredView)
{
_schedulerProvider.Background.Schedule(() =>
{
try
{
_logger.Info($"Attempting to open a restored view {headeredView.Header}");
//var HeaderedView = new HeaderedView(view);
//TODO: Factory should create the HeaderedView
_windowsController.Register(headeredView);
//do the work on the ui thread
_schedulerProvider.MainThread.Schedule(() =>
{
Views.Add(headeredView);
Selected = headeredView;
});
}
catch (Exception ex)
{
//TODO: Create a failed to load view
_logger.Error(ex, $"There was a problem opening '{headeredView.Header}'");
}
});
}
/// <summary>
/// Adds a parameterized view to the stream.
/// </summary>
/// <param name="name">is the view name, for example "length" for a length window</param>
/// <param name="parameters">is a list of view parameters</param>
/// <returns>stream</returns>
public ProjectedStream AddView(
string name,
params Expression[] parameters)
{
Views.Add(View.Create(null, name, parameters));
return this;
}
private Views GetViews(XmlNodeList viewNodes)
{
if (viewNodes == null ||
viewNodes.Count == 0)
{
return(null);
}
Views views = new Views(viewNodes.Count);
foreach (XmlNode viewNode in viewNodes)
{
string id = viewNode.Attributes["Id"].InnerText;
string displayName = viewNode["a:Name"].InnerText;
string name = viewNode["a:Code"].InnerText;
string comment = viewNode["a:Comment"] != null ? viewNode["a:Comment"].InnerText : string.Empty;
View view = new View(id, displayName, name, comment);
view.OriginalName = name;
view.Columns = this.GetColumns(viewNode);
views.Add(id, view);
}
return(views);
}
public MyViewData()
{
Views.Clear();
Views.Add(new TextEditor()
{
Tag = "Avalon TextEditor", Text = TestString
});
Views.Add(new TextEditor()
{
Tag = "Avalon TextEditor", Text = TestString
});
Views.Add(new RichTextBox(new FlowDocument(new Paragraph(new Run(TestString))))
{
Tag = "WPF RichTextBox", VerticalScrollBarVisibility = ScrollBarVisibility.Auto
});
Views.Add(new WindowsFormsHost()
{
Child = new System.Windows.Forms.TextBox()
{
Text = TestString, HideSelection = false, Multiline = true
}, Tag = "WinForms TextBox"
});
Views.Add(new WindowsFormsHost()
{
Child = new System.Windows.Forms.RichTextBox()
{
Text = TestString, HideSelection = false
}, Tag = "WinForms RichTextBox"
});
//Views.Add(new TextBox() { Tag = "WPF TextBox (*)", Text = TestString, VerticalScrollBarVisibility = ScrollBarVisibility.Auto });
ActiveView = Views[0];
}
private void OpenFile(FileInfo file)
{
_schedulerProvider.Background.Schedule(() =>
{
try
{
_logger.Info($"Attempting to open '{file.FullName}'");
RecentFiles.Add(file);
//1. resolve TailViewModel
var factory = _objectProvider.Get <TailViewModelFactory>();
var viewModel = factory.Create(file);
//2. Display it
var newItem = new ViewContainer(new FileHeader(file), viewModel);
_windowsController.Register(newItem);
_logger.Info($"Objects for '{file.FullName}' has been created.");
//do the work on the ui thread
_schedulerProvider.MainThread.Schedule(() =>
{
Views.Add(newItem);
_logger.Info($"Opened '{file.FullName}'");
Selected = newItem;
});
}
catch (Exception ex)
{
//TODO: Create a failed to load view
_logger.Error(ex, $"There was a problem opening '{file.FullName}'");
}
});
}
public WindowViewModel(
ViewContainer.Factory viewContainerFactory,
MenuBuilder.Factory menuItemsFactory,
IInterTabClient interTabClient)
{
_viewContainerFactory = viewContainerFactory;
_menuItemsFactory = menuItemsFactory;
InterTabClient = interTabClient;
_showMenuCommand = ReactiveCommand.Create(ShowMenu, Observable.Return <bool>(Selected != null && !(Selected.Content is MenuBuilder)));
ShowInGitHubCommand = ReactiveCommand.Create(() => Process.Start("https://github.com/RolandPheasant"));
var menuController = Views.ToObservableChangeSet()
.Filter(vc => vc.Content is MenuBuilder)
.Transform(vc => (MenuBuilder)vc.Content)
.MergeMany(menuItems => menuItems.ItemCreated)
.Subscribe(item =>
{
Views.Add(item);
Selected = item;
});
_cleanUp = Disposable.Create(() =>
{
menuController.Dispose();
foreach (var disposable in Views.Select(vc => vc.Content).OfType <IDisposable>())
{
disposable.Dispose();
}
});
}
public MainWindowViewModel(IViewAwareStatus viewAwareStatusService, IMessageBoxService messageBoxService)
{
this.viewAwareStatusService = viewAwareStatusService;
this.viewAwareStatusService.ViewLoaded += ViewAwareStatusService_ViewLoaded;
this.MessageBoxService = messageBoxService;
this.UIVisualizerService = ViewModelRepository.Instance.Resolver.Container.GetExport <IUIVisualizerService>().Value;
this.DisplayName = "Main Window";
this.ViewProfileCommand = new CommandBase <User>(o => this.ExecuteViewProfileCommand(o));
if (Designer.IsInDesignMode)
{
return;
}
// add view
WorkspaceData workspace = new WorkspaceData(@"/XRMS.Presentation;component/Images/Cashier.png",
"CashierOrdersView", null, "Orders Management", false);
Views.Add(workspace);
SetActiveWorkspace(workspace);
_refreshingTimer = new DispatcherTimer();
_refreshingTimer.Tick += new EventHandler(OnRefreshingData);
_refreshingTimer.Interval = TimeSpan.FromMilliseconds(1000);
_refreshingTimer.Start();
ReadRestaurantInfo();
}
public ViewPage ToResult(ControllerConfiguration configuration)
{
if (!(_requiresMetaData))
{
Fields.Clear();
Expressions = null;
}
else
{
XPathNodeIterator viewIterator = configuration.Navigator.Select("/c:dataController/c:views/c:view[not(@virtualViewId!=\'\')]", configuration.Resolver);
while (viewIterator.MoveNext())
{
Views.Add(new View(viewIterator.Current, configuration.Resolver));
}
XPathNodeIterator actionGroupIterator = configuration.Navigator.Select("/c:dataController/c:actions//c:actionGroup", configuration.Resolver);
while (actionGroupIterator.MoveNext())
{
ActionGroups.Add(new ActionGroup(actionGroupIterator.Current, configuration.Resolver));
}
foreach (DataField field in Fields)
{
PopulateStaticItems(field, null);
}
}
if (_originalFilter != null)
{
_filter = _originalFilter;
}
return(this);
}
public ViewPage ToResult(ControllerConfiguration configuration, XPathNavigator mainView)
{
if (!(_requiresMetaData))
{
Fields.Clear();
Expressions = null;
}
else
{
XPathNodeIterator viewIterator = configuration.Navigator.Select("/c:dataController/c:views/c:view[not(@virtualViewId!=\'\')]", configuration.Resolver);
while (viewIterator.MoveNext())
{
Views.Add(new View(viewIterator.Current, mainView, configuration.Resolver));
}
XPathNodeIterator actionGroupIterator = configuration.Navigator.Select("/c:dataController/c:actions//c:actionGroup", configuration.Resolver);
while (actionGroupIterator.MoveNext())
{
ActionGroups.Add(new ActionGroup(actionGroupIterator.Current, configuration.Resolver));
}
foreach (DataField field in Fields)
{
PopulateStaticItems(field, null);
}
}
if (_originalFilter != null)
{
_filter = _originalFilter;
}
if (RequiresMetaData && ((HttpContext.Current != null) && (HttpContext.Current.Session != null)))
{
LEVs = ((FieldValue[])(HttpContext.Current.Session[String.Format("{0}$LEVs", _controller)]));
}
AddPivotHeadersToFields();
return(this);
}
public override IList <DatabaseView> Views(string viewName)
{
var views = new Views(Owner, viewName)
.Execute(ConnectionAdapter);
if (string.IsNullOrEmpty(viewName) || !views.Any())
{
if (_serverVersion == 0)
{
_serverVersion = new ServerVersion().Execute(ConnectionAdapter);
}
var materializedViews = new MaterializedViews(Owner, viewName)
{
ServerVersion = _serverVersion
};
var mviews = materializedViews
.Execute(ConnectionAdapter);
foreach (var mview in mviews)
{
views.Add(mview);
}
}
return(views);
}
public void AddView()
{
try
{
if (string.IsNullOrWhiteSpace(TypeName))
{
return;
}
var match = Views.FirstOrDefault(v => v.TypeName == TypeName);
if (match != null)
{
return;
}
var pv = new ProjectView
{
Deleted = false,
Persisted = false,
TypeName = TypeName
};
Views.Add(pv);
TypeName = String.Empty;
}
catch (Exception ex)
{
ToolboxApp.Log.Error(ex, $"Unable to add new view: {TypeName}.");
}
}
private SpecificObjectInfo AddSpecificObject(SpecificObjectInfo obj, bool reuseGroupId)
{
var res = obj.CloneSpecificObject(this);
if (!reuseGroupId)
{
res.GroupId = Guid.NewGuid().ToString();
}
switch (obj.ObjectType)
{
case DatabaseObjectType.View:
Views.Add((ViewInfo)res);
break;
case DatabaseObjectType.StoredProcedure:
StoredProcedures.Add((StoredProcedureInfo)res);
break;
case DatabaseObjectType.Function:
Functions.Add((FunctionInfo)res);
break;
case DatabaseObjectType.Trigger:
Triggers.Add((TriggerInfo)res);
break;
}
return(res);
}
private void Views_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
Views.Add(e.NewItems[0].ToString());
break;
case NotifyCollectionChangedAction.Remove:
Views.Remove(e.OldItems[0].ToString());
break;
case NotifyCollectionChangedAction.Replace:
break;
case NotifyCollectionChangedAction.Move:
break;
case NotifyCollectionChangedAction.Reset:
Views.Clear();
foreach (var view in region.Views)
{
Views.Add(view.ToString());
}
break;
default:
break;
}
}
private void LoadViews(IEnumerable <ScriptedModel> data2)
{
foreach (ScriptedModel item in data2)
{
item.DatabaseName = name;
Views.Add(item);
}
}
public CRActivityMaint()
{
CRCaseActivityHelper.Attach(this);
PXView relEntityView = new PXView(this, true, new Select <CRSMEmail>(), new PXSelectDelegate(GetRelatedEntity));
Views.Add("RelatedEntity", relEntityView);
}
/// <summary>
/// Adds a parameterized view to the stream.
/// </summary>
/// <param name="namespace">is the view namespace, for example "win" for most data windows</param>
/// <param name="name">is the view name, for example "length" for a length window</param>
/// <param name="parameters">is a list of view parameters</param>
/// <returns>stream</returns>
public ProjectedStream AddView(
string @namespace,
string name,
IList<Expression> parameters)
{
Views.Add(View.Create(@namespace, name, parameters));
return this;
}
/// <summary>Add a new SobekCM View to this resource </summary>
/// <param name="New_View">SobekCM View object</param>
public void Add_View(View_Object New_View)
{
if (Views == null)
{
Views = new List <View_Object>();
}
Views.Add(New_View);
}
public View AddView(string viewRelativePath)
{
var view = new View(viewRelativePath, this);
Views.Add(viewRelativePath, view);
return(view);
}
/// <summary>
/// Adds to view.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="command">The command.</param>
private void AddToView(String name, Command command)
{
if (!Views.ContainsKey(name))
{
Views.Add(name, new CommandNode());
}
Views[name].Add(command);
}
private async Task <bool> OpenFile(IEnumerable <FileInfo> files)
{
OpenedFileCount = files.Count();
if (OpenedFileCount > 1)
{
//Here we can set the dialog window's message
Dialog.text = "Would you like to tail these files?";
//Showing the dialog window
await DialogHost.Show(Dialog, FileOpen.Id);
//Testing the pushed button
if (Dialog.Button)
{
//Tailing multiple files
_schedulerProvider.Background.Schedule(() =>
{
//await DialogHost.Show(Dialog, DialogNames.EntireWindow);
try
{
_logger.Info($"Attempting to open '{files.Count()}' files");
var factory = _objectProvider.Get <TailViewModelFactory>();
var viewModel = factory.Create(files);
var newItem = new ViewContainer(new FilesHeader(files), viewModel);
_windowsController.Register(newItem);
//_logger.Info($"Objects for '{file.FullName}' has been created.");
//do the work on the ui thread
_schedulerProvider.MainThread.Schedule(() =>
{
Views.Add(newItem);
_logger.Info($"Opened '{files.Count()}' files");
Selected = newItem;
});
}
catch
{
// ignored
}
});
}
else
{
foreach (var fileInfo in files)
{
OpenFile(fileInfo);
}
}
}
else
{
OpenFile(files.ElementAt(0));
}
return(true);
}
protected virtual void CreateViews()
{
if (UpperRight != null)
{
Views.Add(UpperRight);
Views.Add(UpperLeft);
Views.Add(LowerLeft);
}
}
public MaxWidthBinder(IList <View> views)
{
foreach (var view in views)
{
Views.Add(view);
view.PropertyChanged += ViewPropertyChanged;
}
OnPropertyChanged("MaxWidth");
}
private Views GetViews(XmlNodeList viewNodes)
{
if (viewNodes == null ||
viewNodes.Count == 0) return null;
Views views = new Views(viewNodes.Count);
foreach (XmlNode viewNode in viewNodes)
{
string id = viewNode.Attributes["Id"].InnerText;
string displayName = viewNode["a:Name"].InnerText;
string name = viewNode["a:Code"].InnerText;
string comment = viewNode["a:Comment"] != null ? viewNode["a:Comment"].InnerText : string.Empty;
View view = new View(id, displayName, name, comment);
view.OriginalName = name;
view.Columns = this.GetColumns(viewNode);
views.Add(id, view);
}
return views;
}
private Views GetViews(string originalDbName, string connectionString)
{
Views views = new Views(10);
string sqlCmd = string.Format("SELECT TABLE_NAME FROM VIEWS WHERE TABLE_SCHEMA = '{0}'", originalDbName);
MySqlDataReader dr = MySqlHelper.ExecuteReader(connectionString, sqlCmd);
while (dr.Read())
{
string id = dr.GetString(0);
string displayName = dr.GetString(0);
string name = dr.GetString(0);
string comment = string.Empty;
View view = new View(id, displayName, name, comment);
view.OriginalName = name;
view.Columns = this.GetColumns(displayName, originalDbName, connectionString);
views.Add(id, view);
}
dr.Close();
return views;
}
private Views GetViews(string connectionString)
{
Views views = new Views(10);
string sqlCmd = "select [name],[object_id] from sys.views where type='V'";
SqlDataReader dr = SqlHelper.ExecuteReader(connectionString, CommandType.Text, sqlCmd);
while (dr.Read())
{
string id = dr.GetString(0);
string displayName = dr.GetString(0);
string name = dr.GetString(0);
string comment = string.Empty;
int objectId = dr.GetInt32(1);
View view = new View(id, displayName, name, comment);
view.OriginalName = name;
view.Columns = this.GetColumns(objectId, connectionString);
views.Add(id, view);
}
dr.Close();
return views;
}
protected void createTabXML()
{
Views allViews = new Views();
DataTable viewtable = ViewDataTable;
foreach (DataRow drViewRow in viewtable.Rows)
{
string ViewID = drViewRow[Constants.ViewField.ViewID].ToString();
string View = drViewRow[Constants.ViewField.View].ToString();
string UserGroup = drViewRow[Constants.ViewField.UserGroup].ToString();
string Permission = drViewRow[Constants.ViewField.Permission].ToString();
bool IsActionMenu = Convert.ToBoolean(drViewRow[Constants.ViewField.IsActionMenu].ToString());
bool IsDataSheet = Convert.ToBoolean(drViewRow[Constants.ViewField.IsDataSheet].ToString());
bool IsRssFeed = Convert.ToBoolean(drViewRow[Constants.ViewField.IsRssFeed].ToString());
bool IsAlertMe = Convert.ToBoolean(drViewRow[Constants.ViewField.IsAlertMe].ToString());
int ViewRowID = Convert.ToInt32(drViewRow[Constants.RowID]);
ViewSetting v = new ViewSetting(ViewID, ViewRowID, View, UserGroup, Permission, IsActionMenu, IsDataSheet, IsRssFeed, IsAlertMe);
allViews.Add(v);
}
SPSecurity.RunWithElevatedPrivileges(delegate
{
using (SPSite objSite = new SPSite(SPContext.Current.Web.Url.ToString()))
{
using (SPWeb objWeb = objSite.OpenWeb())
{
objWeb.AllowUnsafeUpdates = true;
SPList list = objWeb.Lists[new Guid(Request.QueryString["List"])];
string xml = allViews.ToString();
if (allViews.Count > 0 && Helper.IsValidXml(xml))
{
Helper.CreateConfigFile(list, Constants.ConfigFile.ViewPermissionsFile, xml);
}
else
{
Helper.DeleteConfigFile(list, Constants.ConfigFile.ViewPermissionsFile, xml);
}
objWeb.AllowUnsafeUpdates = false;
}
}
});
}
