private void FinanceForm_Loaded(object sender, RoutedEventArgs e) { if (m_lstTemplate == null) { m_lstTemplate = DataFactory.Instance.GetTemplateExecuter().GetExcelTemplate("利润表"); m_lstTemplate.Sort((a, b) => { var x = long.Parse(a.b); var y = long.Parse(b.b); if (x > y) { return(1); } else if (x == y) { return(0); } else { return(-1); } }); } SheetModel = SheetModel.DATA; }
public async Task <SheetModel> ToModel(Sheet sheet) { // Load form input groups. var formInputGroups = await _unitOfWork.SheetRepository.GetFormInputGroups(sheet.SheetId); // Instantiate sheet model. var sheetModel = new SheetModel { SheetId = sheet.SheetId, UserId = sheet.UserId, }; // Instantiate a form input group model for each form input group. var formInputGroupModels = new List <FormInputGroupModel>(); foreach (var formInputGroup in formInputGroups) { // Convert form input group object to model. var formInputGroupModel = await GetFormInputGroup(formInputGroup); formInputGroupModels.Add(formInputGroupModel); } sheetModel.FormGroups = formInputGroupModels.AsEnumerable(); return(sheetModel); }
protected override object SetUpMember(int index, object member) { SheetModel sheet = ((SheetModel)member); SSSheetNetworkService service = null; using (Synchronizer.Lock(m_Service.m_Slide.SyncRoot)) { if (this.m_Service.GetSubmissionStyle() != SlideModel.StudentSubmissionStyle.Normal) { using (Synchronizer.Lock(sheet.SyncRoot)) { if ((sheet.Disposition & SheetDisposition.Remote) == 0 && (sheet is RealTimeInkSheetModel)) { if (this.m_Service.GetSubmissionStyle() == SlideModel.StudentSubmissionStyle.Shared) { Message.AddLocalRef(this.m_Service.GetSubmissionSlideGuid(), this.m_Service.m_Slide); } //System.Windows.Forms.MessageBox.Show( sheet.GetType().ToString() ); service = new SSRealTimeInkSheetNetworkService(this.m_Service.m_Sender, this.m_Service.m_Presentation, this.m_Service.m_Deck, this.m_Service.m_Slide, (RealTimeInkSheetModel)sheet, this.m_Selector); } } } } return(service); }
public static SheetRenderer ForSheet(SlideDisplayModel display, SheetModel sheet) { // TODO: Make this pluggable by dynamically loading available renderers, mapped by the types they support. if (sheet is InkSheetModel) { if (sheet is RealTimeInkSheetModel) { return(new RealTimeInkSheetRenderer(display, (RealTimeInkSheetModel)sheet)); } else { return(new InkSheetRenderer(display, (InkSheetModel)sheet)); } } else if (sheet is ImageSheetModel) { return(new ImageSheetRenderer(display, (ImageSheetModel)sheet)); } else if (sheet is TextSheetModel) { return(new TextSheetRenderer(display, (TextSheetModel)sheet)); } else if (sheet is QuickPollSheetModel) { return(new QuickPollSheetRenderer(display, (QuickPollSheetModel)sheet)); } else if (sheet is XPSPageSheetModel) { return(new XPSPageRenderer(display, (XPSPageSheetModel)sheet)); } else { return(null); } }
public static Message RemoteForSheet(SheetModel sheet, SheetCollection collection) { SheetModel newModel = null; if (sheet is ImageSheetModel) { newModel = sheet; } else if (sheet is RealTimeInkSheetModel) { using (Synchronizer.Lock(sheet.SyncRoot)) { newModel = new RealTimeInkSheetModel(sheet.Id, sheet.Disposition | SheetDisposition.Remote, sheet.Bounds); using (Synchronizer.Lock(newModel.SyncRoot)) ((RealTimeInkSheetModel)newModel).CurrentDrawingAttributes = ((RealTimeInkSheetModel)sheet).CurrentDrawingAttributes; } } else if (sheet is InkSheetModel) { newModel = sheet; } else if (sheet is TextSheetModel) { newModel = sheet; } else if (sheet is QuickPollSheetModel) { newModel = sheet; } else if (sheet is XPSPageSheetModel) { newModel = sheet; } return(SheetMessage.ForSheet(newModel, collection)); }
public static ExcelModel ConvertDictionaryToExcelModel(IEnumerable <Dictionary <string, object> > data, ExcelExporterOptions options) { var sheetTitle = options.SheetTitle; var excel = new ExcelModel { Sheets = new List <SheetModel>() }; var sheet = SheetModel.Create(sheetTitle); excel.Sheets.Add(sheet); var list = data.ToList(); var title = list.FirstOrDefault(); if (title == null) { return(excel); } var columns = title.Keys.Select((c, i) => new ExcelColumn { Order = i, Title = c, Type = typeof(string) }).ToList(); sheet.Columns = AttachColumns(columns, options); sheet.Rows = list; return(excel); }
/// <summary> /// Update a sheet's properties. /// </summary> /// <param name="id">Sheet id of sheet being updated.</param> /// <param name="sheetModel">Sheet model containing all properties to be updated.</param> /// <returns>Sheet model of the sheet with updated properties.</returns> public async Task <ActionResult <SheetModel> > UpdateSheet(Guid?id, SheetModel sheetModel) { if (ModelState.IsValid) { if (id == null) { return(BadRequest()); } var identity = HttpContext.User.Identity as ClaimsIdentity; var userId = Guid.Parse(identity.Claims.First(claim => claim.Type == "Id").Value); sheetModel.SheetId = (Guid)id; try { return(await _service.UpdateSheet(sheetModel, userId)); } catch (SecurityException) { return(Unauthorized()); } catch { return(BadRequest()); } } return(BadRequest()); }
public void SendSheetInformation(SheetModel sheet, SheetMessage.SheetCollection selector, Group receivers) { // TODO: Also pass the index so the sheet can be inserted into the correct index on the remote side. Message message, deck, slide; message = new PresentationInformationMessage(this.m_Presentation); message.Group = receivers; message.InsertChild(deck = new DeckInformationMessage(this.m_Deck)); deck.InsertChild(slide = new SlideInformationMessage(this.m_Slide)); Message sm = SheetMessage.RemoteForSheet(sheet, selector); //if sm is null that means that the sheet is an instructor note and shouldn't be sent. if (sm != null) { slide.InsertChild(sm); } using (Synchronizer.Lock(this.m_Slide.SyncRoot)) { message.Tags = new MessageTags(); message.Tags.SlideID = this.m_Slide.Id; } if (sheet is ImageSheetModel && ((ImageSheetModel)sheet).Image != null) { using (Synchronizer.Lock(sheet.SyncRoot)) { this.m_Sender.Send(message); } } else { this.m_Sender.Send(message); } }
/// <summary> /// Performs a deep copy of the given SheetModel. /// If the given sheetmodel is not an InkSheet, then returns itself. /// </summary> /// <param name="s">The SheetModel to copy</param> /// <returns>The given sheetmodel if not an InkSheetModel, otherwise a deep copy of the InkSheetModel</returns> protected SheetModel InkSheetDeepCopyHelper(SheetModel s) { using (Synchronizer.Lock(s.SyncRoot)) { InkSheetModel t; // Only copy InkSheetModels if (s is InkSheetModel) { if (s is RealTimeInkSheetModel) { // Make a deep copy of the SheetModel t = new RealTimeInkSheetModel(Guid.NewGuid(), s.Disposition | SheetDisposition.Remote, s.Bounds, ((RealTimeInkSheetModel)s).Ink.Clone()); using (Synchronizer.Lock(t.SyncRoot)) { ((RealTimeInkSheetModel)t).CurrentDrawingAttributes = ((RealTimeInkSheetModel)s).CurrentDrawingAttributes; } } else { // Make a deep copy of the SheetModel t = new InkSheetModel(Guid.NewGuid(), s.Disposition, s.Bounds, ((InkSheetModel)s).Ink.Clone()); } // This is a new object so add it to the local references Message.AddLocalRef(t.Id, t); return(t); } } return(s); }
protected override object SetUpMember(int index, object member) { SheetModel sheet = ((SheetModel)member); using (Synchronizer.Lock(sheet.SyncRoot)) { // Don't create a network service for the sheet if it is remote, // UNLESS this is a student submission slide in which case we're responsible for rebroadcasting its ink. if ((sheet.Disposition & SheetDisposition.Remote) != 0 && (this.m_Service.m_Slide.Disposition & SlideDisposition.StudentSubmission) == 0) { return(null); } } Group receivers = Group.AllParticipant; if ((this.m_Service.m_Slide.Disposition & SlideDisposition.StudentSubmission) != 0) { receivers = Group.Submissions; } this.m_Service.SendSheetInformation(sheet, this.m_Selector, receivers); SheetNetworkService service = SheetNetworkService.ForSheet(this.m_Service.m_Sender, this.m_Service.m_Presentation, this.m_Service.m_Deck, this.m_Service.m_Slide, sheet, this.m_Selector); return(service); }
private void FinanceForm_Loaded(object sender, RoutedEventArgs e) { if (m_lstTemplate == null) { m_lstTemplate = DataFactory.Instance.GetTemplateExecuter().GetExcelTemplate("资产负债表"); } var year = DataFactory.Instance.GetSystemProfileExecuter().GetInt(SystemProfileKey.CurrentYear); var period = DataFactory.Instance.GetSystemProfileExecuter().GetInt(SystemProfileKey.CurrentPeriod); var now = DateTime.Now; if (now.Year == year && now.Month == period) { } else { now = CommonUtils.CalcMaxPeriodDate(year, period); } if (m_filter == null) { m_filter = new Dictionary <string, object>(); m_filter.Add("beginYear", now.Year); m_filter.Add("beginPeriod", now.Month); m_filter.Add("endYear", now.Year); m_filter.Add("endPeriod", now.Month); } SheetModel = SheetModel.DATA; }
public async Task <SheetModel> Update(SheetModel model) { using (var db = new ScribsDbContext()) { var user = GetUser(db); var sheet = await Sheet.Factory.GetInstanceAsync(db, model.Id); if (sheet.Name != model.Name) { sheet.Name = model.Name; } var kept = new HashSet <int>(); foreach (var fieldModel in model.Fields.Where(o => o.Id > 0)) { kept.Add(fieldModel.Id); var field = sheet.SheetFields.Single(o => o.Id == fieldModel.Id); field.Value = fieldModel.Value; } foreach (var fieldModel in model.Fields.Where(o => o.Id == 0)) { CreateField(db, sheet, fieldModel); } foreach (var field in sheet.SheetFields.Where(o => !kept.Contains(o.Id))) { sheet.SheetFields.Remove(field); SheetField.Factory.Delete(db, field); } await db.SaveChangesAsync(); return(SheetModelUtils.GetModel(sheet)); } }
public List <SheetModel> CreateModels() { var models = new List <SheetModel>(); foreach (var sheet in _sheets) { var worksheetpart = (WorksheetPart)_document.WorkbookPart.GetPartById(sheet.Id); var worksheet = worksheetpart.Worksheet; var sharedStringTablePart = _document.WorkbookPart.SharedStringTablePart; var descriptionCell = worksheet.Descendants <Cell>().FirstOrDefault(c => c.CellReference.Value == "A1"); if (descriptionCell == null || string.IsNullOrWhiteSpace(GetValue(descriptionCell, sharedStringTablePart))) { continue; } var model = new SheetModel { TabbleEnName = sheet.Name, TableDescription = GetValue(descriptionCell, sharedStringTablePart), Entity = new List <EntityModel>(), Mapping = new List <MappingModel>(), Search = new List <SearchModel>(), Enums = new List <EnumModel>() }; CreateSubModels(worksheet, model.Entity, model.Mapping, model.Search, model.Enums, sharedStringTablePart); models.Add(model); } return(models); }
public static SheetMatch ForSheet(EventQueue sender, SheetModel src, SheetModel dst) { // FIXME: Create SheetNetworkService classes for sheets other than InkSheetModels. if (src is RealTimeInkSheetModel) { return(new RealTimeInkSheetMatch(sender, (RealTimeInkSheetModel)src, (RealTimeInkSheetModel)dst)); } else if (src is InkSheetModel) { return(new InkSheetMatch(sender, (InkSheetModel)src, (InkSheetModel)dst)); } else if (src is ImageSheetModel) { return(null); } else if (src is TextSheetModel) { return(null); } else if (src is QuickPollSheetModel) { return(null); } else { return(null); } }
protected override void TearDownMember(int index, object member, object tag) { if (tag == null) { return; } SheetModel sheet = ((SheetModel)member); Message message, deck, slide; message = new PresentationInformationMessage(this.m_Service.m_Presentation); message.InsertChild(deck = new DeckInformationMessage(this.m_Service.m_Deck)); deck.InsertChild(slide = new SlideInformationMessage(this.m_Service.m_Slide)); slide.InsertChild(new SheetRemovedMessage(sheet, this.m_Selector)); using (Synchronizer.Lock(this.m_Service.m_Slide.SyncRoot)) { message.Tags = new MessageTags(); message.Tags.SlideID = this.m_Service.m_Slide.Id; } this.m_Service.m_Sender.Send(message); ((SheetNetworkService)tag).Dispose(); }
protected override object SetUpMember(int index, object member) { SheetModel sheet = ((SheetModel)member); // Add the SheetMatch to the collection of matches using (Synchronizer.Lock(sheet.SyncRoot)) { using (Synchronizer.Lock(this.m_Owner.m_DestSlide.SyncRoot)) { if (sheet is RealTimeInkSheetModel) { // Add the sheet RealTimeInkSheetModel m = new RealTimeInkSheetModel(Guid.NewGuid(), sheet.Disposition, sheet.Bounds); this.m_Owner.m_DestSlide.AnnotationSheets.Add(m); // Add the sheet match SheetMatch toAdd = SheetMatch.ForSheet(this.m_Owner.m_Sender, sheet, m); this.m_Owner.m_SheetMatches.Add(toAdd); } else if (sheet is InkSheetModel) { // Add the sheet InkSheetModel m = new InkSheetModel(Guid.NewGuid(), sheet.Disposition, sheet.Bounds); this.m_Owner.m_DestSlide.AnnotationSheets.Add(m); // Add the sheet match SheetMatch toAdd = SheetMatch.ForSheet(this.m_Owner.m_Sender, sheet, m); this.m_Owner.m_SheetMatches.Add(toAdd); } } } return(null); }
public void CreateMusicPiece(string filename) { _score = MusicXmlParser.GetScore(filename); Guide = new GuidesController(MidiController) { Score = _score, Piano = Piano, Sheet = SheetController }; Sheet = SheetController.SheetModel; //stop program from crashing when reloading musicpiece. Sheet.Reset(); AddGreatStaffsToSheet(); AddMeasuresToGreatStaffs(); AddNotesToMeasures(); Guide.staffEndReached += staffEndReached; Guide.GoToFirstStaff += GoToFirstStaff; Guide.HoldPosition += this.HoldPosition; MidiController.Guide = Guide; KeyboardController.Guide = Guide; }
private bool determineIfDisplay(SheetModel sm) { using (Synchronizer.Lock(this.m_SlideDisplay.SyncRoot)) { using (Synchronizer.Lock(sm.SyncRoot)) { return((sm.Disposition & this.m_SlideDisplay.SheetDisposition) != 0); } } }
public StackPanel StandardSheet() { GreatStaffModel greatStaffModel = new GreatStaffModel(); Sheet = new SheetModel(); Sheet.GreatStaffModelList.Add(greatStaffModel); return(Sheet.DrawSheet()); }
private void FinanceForm_Loaded(object sender, RoutedEventArgs e) { if (m_lstTemplate == null) { m_lstTemplate = DataFactory.Instance.GetTemplateExecuter().GetExcelTemplate("利润表"); } SheetModel = SheetModel.DATA; }
protected SheetUndoService(UndoModel undo, DeckModel deck, SlideModel slide, SheetModel sheet) { this.m_Undo = undo; this.m_Deck = deck; this.m_Slide = slide; this.m_Sheet = sheet; this.m_Sheet.Changed["Bounds"].Add(new PropertyEventHandler(this.HandleSheetChanged)); }
/// <summary> /// Construct the sheet model /// </summary> /// <param name="sender">The event queue for async event handling</param> /// <param name="srcSheet">The source sheet model</param> /// <param name="dstSheet">The destination sheet model</param> /// <param name="selector">Unknown</param> public SheetMatch(EventQueue sender, SheetModel srcSheet, SheetModel dstSheet /*, SheetMessage.SheetCollection selector*/) { this.m_Sender = sender; this.m_SourceSheet = srcSheet; this.m_DestSheet = dstSheet; this.m_BoundsChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_Sender, new PropertyEventHandler(this.HandleBoundsChanged)); this.m_SourceSheet.Changed["Bounds"].Add(this.m_BoundsChangedDispatcher.Dispatcher); }
public SSSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector) { this.m_Sender = sender; this.m_Presentation = presentation; this.m_Deck = deck; this.m_Slide = slide; this.m_Sheet = sheet; this.m_Selector = selector; }
/// <summary> /// Handle the button being clicked /// </summary> /// <param name="args">The event args</param> protected override void OnClick(EventArgs args) { if (this.m_Slide == null) { return; } using (Synchronizer.Lock(this.m_Slide.SyncRoot)) { InkSheetModel inks = null; // TODO: This code is duplicated in InkSheetAdapter. Extract to a "ActiveInkAnnotationSheet" property of the SlideModel. // Find the *top-most* *local* InkSheetModel in the annotation layer. for (int i = m_Slide.AnnotationSheets.Count - 1; i >= 0; i--) { SheetModel sheet = m_Slide.AnnotationSheets[i]; if ((sheet.Disposition & SheetDisposition.Remote) != 0) { continue; } if (sheet is InkSheetModel) { inks = ((InkSheetModel)sheet); } //else if (sheet is EditableSheetModel ) { // ///only erase the sheet model if the user made it // ///(i.e. it is editable. If this is sent from another // ///person, don't erase it). // EditableSheetModel edit_sheet = (EditableSheetModel)sheet; // if (edit_sheet.IsEditable) { // m_Slide.AnnotationSheets.Remove(sheet); // } //} } if (inks != null) { using (Synchronizer.Lock(inks.SyncRoot)) { Strokes strokes = inks.Ink.Strokes; using (Synchronizer.Lock(strokes.SyncRoot)) { int[] ids = new int[inks.Ink.Strokes.Count]; for (int j = 0; j < strokes.Count; j++) { ids[j] = strokes[j].Id; } StrokesEventArgs sea = new StrokesEventArgs(ids); inks.OnInkDeleting(sea); inks.Ink.DeleteStrokes(); inks.OnInkDeleted(sea); } } } } base.OnClick(args); }
public SheetMessage(SheetModel sheet, SheetCollection collection) : base(sheet.Id) { this.AddLocalRef(sheet); this.Disposition = sheet.Disposition; this.SheetCollectionSelector = collection; using (Synchronizer.Lock(sheet.SyncRoot)) { this.Bounds = sheet.Bounds; } this.Height = sheet.Height; }
protected override void TearDownMember(int index, object member, object tag) { if (tag == null) { return; } SheetModel sheet = ((SheetModel)member); ((SheetNetworkService)tag).Dispose(); }
public static Column FillColumn(SheetModel sheetDTO, Column column) { foreach (var row in sheetDTO.Rows) { var cell = row.Cells.FirstOrDefault(c => c.ColumnLetter == column.Name); if (cell != null) { column.Cells.Add(cell); } } return(column); }
public SheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector) { this.m_Sender = sender; this.m_Presentation = presentation; this.m_Deck = deck; this.m_Slide = slide; this.m_Sheet = sheet; this.m_Selector = selector; this.m_BoundsChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.Sender, new PropertyEventHandler(this.HandleBoundsChanged)); this.m_Sheet.Changed["Bounds"].Add(this.m_BoundsChangedDispatcher.Dispatcher); }
public static ExcelModel ConvertObjectToExcelModel <TModel>(IEnumerable <TModel> data, ExcelExporterOptions options) { var sheetTitle = options.SheetTitle; var excel = new ExcelModel { Sheets = new List <SheetModel>() }; if (string.IsNullOrWhiteSpace(sheetTitle)) { var classAttr = ExcelUtil.GetClassExportAttribute <TModel>(); sheetTitle = classAttr.Item1 == null ? sheetTitle : classAttr.Item1.Title; } var sheet = SheetModel.Create(sheetTitle); excel.Sheets.Add(sheet); var attrDict = ExcelUtil.GetPropertiesAttributesDict <TModel>(); var objKeysArray = attrDict.OrderBy(c => c.Value.ExcelTitleAttribute.Order).ToArray(); var columns = new List <ExcelColumn>(); for (var i = 0; i < objKeysArray.Length; i++) { var titleAttr = objKeysArray[i].Value.ExcelTitleAttribute; var fontAttr = objKeysArray[i].Value.ExcelColumnFontAttribute; var column = new ExcelColumn { Title = titleAttr.Title, Type = objKeysArray[i].Key.PropertyType, Order = i, Font = fontAttr == null ? null : new Font(fontAttr.FontName, fontAttr.FontHeightInPoints, fontAttr.Color, fontAttr.IsBold), }; columns.Add(column); } sheet.Columns = AttachColumns(columns, options); foreach (var item in data.Where(c => c != null)) { var row = new Dictionary <string, object>(); foreach (var column in objKeysArray) { var prop = column.Key; row[column.Value.ExcelTitleAttribute.Title] = prop.GetValue(item, null); } sheet.Rows.Add(row); } return(excel); }
public static Sheet MapToSheet(SheetModel sheetDTO) { var sheet = new Sheet(); int columnNumber = 0; foreach (var row in sheetDTO.Rows) { sheet.Data[0].RowData.Add(MapToRowData(row)); sheet.Data[0].ColumnMetadata.Add(MapToColumnMetadata(sheetDTO.Columns[columnNumber])); columnNumber++; } return(sheet); }