public void CreateStyleRule(Style style, IUrlResolutionService urlResolver, string selection) { StyleEntry entry = new StyleEntry(); entry.Style = style; entry.UrlResolver = urlResolver; entry.Selection = selection; entries.Add(entry); }
private PitchBendMessage GetPitchBendMessage(StyleEntry msg) { TomiSoft.RolandStyleReader.PitchWheelMessage m = (TomiSoft.RolandStyleReader.PitchWheelMessage)msg.Message; return(new PitchBendMessage( this.Device, ChannelMappings[msg.Instrument], 0, m.TotalTime )); }
/// <summary> /// Runs all runCommands that are applicable for the current state. /// </summary> internal void RunCommands() { StyleEntry[] styleEntries = availableStyles.Array; for (int i = 0; i < availableStyles.Count; i++) { StyleEntry entry = styleEntries[i]; if ((entry.state & currentState) != 0) { RunCommands(entry.styleRunCommand.runCommands); } } }
private NoteOnOffMessage GetNoteOnOffMessage(StyleEntry msg) { TomiSoft.RolandStyleReader.NoteMessage m = (TomiSoft.RolandStyleReader.NoteMessage)msg.Message; return(new NoteOnOffMessage( this.Device, ChannelMappings[msg.Instrument], (Pitch)((m.Note < 128) ? m.Note : 1), m.Velocity, m.TotalTime / 120f, this.clock, m.Length )); }
private Message ConvertMessage(StyleEntry msg) { switch (msg.Message.MessageType) { case MidiMessageType.Note: return(this.GetNoteOnOffMessage(msg)); case MidiMessageType.PitchWheel: return(this.GetPitchBendMessage(msg)); case MidiMessageType.ControlChange: return(this.GetControlChangeMessage(msg)); default: return(null); } }
private void lwMessages_DoubleClick(object sender, EventArgs e) { if (lwMessages.SelectedIndices.Count == 1) { StyleEntry entry = (StyleEntry)lwMessages.SelectedItems[0].Tag; switch (entry.Message.MessageType) { case MidiMessageType.Note: NoteMessage msg = (NoteMessage)entry.Message; NoteEventEditDialog dlg = new NoteEventEditDialog(this.Data.Measure, msg); if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK) { } break; } } }
public void Highlight(Scintilla editor, int startPos, int endPos) { int length = (endPos - startPos) + 1; editor.StartStyling(startPos); editor.SetStyling(length, 0); var rangeEntry = new StyleEntry(startPos, length, 0); var intersectingEntries = _entries.Where(r => r.InterectsWith(rangeEntry)); foreach (StyleEntry entry in intersectingEntries) { int s = Math.Max(startPos, entry.Index); int e = Math.Min(entry.Index + (entry.Length - 1), endPos); int l = (e - s) + 1; editor.StartStyling(s); editor.SetStyling(l, entry.Style); } }
private Midi.ControlChangeMessage GetControlChangeMessage(StyleEntry msg) { TomiSoft.RolandStyleReader.ControlChangeMessage m = (TomiSoft.RolandStyleReader.ControlChangeMessage)msg.Message; Dictionary <ControlType, Control> ControlMappings = new Dictionary <ControlType, Control>() { { ControlType.Chorus, Control.ChorusLevel }, { ControlType.Expression, Control.Expression }, { ControlType.Pan, Control.Pan }, { ControlType.Reverb, Control.ReverbLevel } }; return(new Midi.ControlChangeMessage( this.Device, ChannelMappings[msg.Instrument], ControlMappings[m.Control], m.Value, m.TotalTime )); }
internal void EnterState(StyleState state) { if (state == StyleState.Normal || (currentState & state) != 0) { return; } StyleState oldState = currentState; currentState |= state; if ((containedStates & state) == 0) { return; } LightList <StylePropertyId> toUpdate = LightList <StylePropertyId> .Get(); IStyleSystem styleSystem = element.application.styleSystem; StyleEntry[] styleEntries = availableStyles.Array; for (int i = 0; i < availableStyles.Count; i++) { StyleEntry entry = styleEntries[i]; // if this is a state we had not been in before, mark it's properties for update if ((entry.state & oldState) == 0 && (entry.state & state) != 0) { AddMissingProperties(toUpdate, entry.styleRunCommand.style); RunCommands(entry.styleRunCommand.runCommands); } } UpdatePropertyMap(toUpdate); LightList <StylePropertyId> .Release(ref toUpdate); }
internal void ExitState(StyleState state) { if (state == StyleState.Normal || (currentState & state) == 0) { return; } StyleState oldState = currentState; currentState &= ~(state); currentState |= StyleState.Normal; if ((containedStates & state) == 0) { return; } LightList <StylePropertyId> toUpdate = LightList <StylePropertyId> .Get(); StyleEntry[] styleEntries = availableStyles.Array; for (int i = 0; i < availableStyles.Count; i++) { StyleEntry entry = styleEntries[i]; // if this a state we were in that is now invalid, mark it's properties for update if ((entry.state & oldState) != 0 && (entry.state & state) != 0) { AddMissingProperties(toUpdate, entry.styleRunCommand.style); RunCommands(entry.styleRunCommand.runCommands, false); } } UpdatePropertyMap(toUpdate); LightList <StylePropertyId> .Release(ref toUpdate); }
public void CreateStyleRule (Style style, IUrlResolutionService urlResolver, string selection) { StyleEntry entry = new StyleEntry (); entry.Style = style; entry.UrlResolver = urlResolver; entry.Selection = selection; entries.Add (entry); }
public bool InterectsWith(StyleEntry other) { bool result = (Index <= other.End) && (End >= other.Index); return(result); }
/// <summary> /// Call once when the server or app is started. Loads all the styles and caches baseline data for later use. /// </summary> /// <param name="onlyDefaults">if true, skip loading the styles from the DB and use Praxismapper's defaults </param> public static void Initialize(bool onlyDefaults = false, IMapTiles mapTiles = null) { MapTiles = mapTiles; List <StyleEntry> styles; if (onlyDefaults) { styles = Singletons.defaultStyleEntries; long i = 1; foreach (var s in styles) { foreach (var p in s.PaintOperations) { p.Id = i++; } } } else { try { //Load TPE entries from DB for app. var db = new PraxisContext(); styles = db.StyleEntries.Include(t => t.StyleMatchRules).Include(t => t.PaintOperations).ToList(); if (styles == null || styles.Count() == 0) { styles = Singletons.defaultStyleEntries; } var bitmaps = db.StyleBitmaps.ToList(); foreach (var b in bitmaps) { cachedBitmaps.Add(b.Filename, b.Data); //Actual MapTiles dll will process the bitmap, we just load it here. } } catch (Exception ex) { //The database doesn't exist, use defaults. Log.WriteLog("Error initializing:" + ex.Message, Log.VerbosityLevels.Errors); styles = Singletons.defaultStyleEntries; } } var groups = styles.GroupBy(s => s.StyleSet); foreach (var g in groups) { allStyleGroups.Add(g.Key, g.Select(gg => gg).OrderBy(gg => gg.MatchOrder).ToDictionary(k => k.Name, v => v)); } //Default style should be transparent, matches anything (assumed other styles were checked first) defaultStyle = new StyleEntry() { MatchOrder = 10000, Name = "unmatched", StyleSet = "mapTiles", PaintOperations = new List <StylePaint>() { new StylePaint() { HtmlColorCode = "00000000", FillOrStroke = "fill", LineWidthDegrees = 1, LinePattern = "solid", LayerId = 101 } }, StyleMatchRules = new List <StyleMatchRule>() { new StyleMatchRule() { Key = "*", Value = "*", MatchType = "default" } } }; MapTiles.Initialize(); }
/// <summary> /// Determine if this StyleEntry matches or not against a Place's tags. Higher performance due to the use of a dictionary. /// </summary> /// <param name="tpe">the StyleEntry to match</param> /// <param name="tags">a Dictionary representing the place's tags</param> /// <returns>true if this rule entry matches against the place's tags, or false if not.</returns> public static bool MatchOnTags(StyleEntry tpe, Dictionary <string, string> tags) { bool OrMatched = false; int orRuleCount = 0; StyleMatchRule entry; //Step 1: check all the rules against these tags. //The * value is required for all the rules, so check it first. for (var i = 0; i < tpe.StyleMatchRules.Count(); i++) { entry = tpe.StyleMatchRules.ElementAt(i); string actualvalue = ""; bool isPresent = tags.TryGetValue(entry.Key, out actualvalue); switch (entry.MatchType) { case "any": if (!isPresent) { return(false); } if (entry.Value == "*") { continue; } if (!entry.Value.Contains(actualvalue)) { return(false); } break; case "or": //Or rules don't fail early, since only one of them needs to match. Otherwise is the same as ANY logic. orRuleCount++; if (!isPresent || OrMatched) //Skip checking the actual value if we already matched on an OR rule. { continue; } if (entry.Value == "*" || entry.Value.Contains(actualvalue)) { OrMatched = true; } break; case "not": if (!isPresent) { continue; } if (entry.Value.Contains(actualvalue) || entry.Value == "*") { return(false); //Not does not want to match this. } break; case "equals": //for single possible values, EQUALS is slightly faster than ANY if (entry.Value == "*" && isPresent) { continue; } if (!isPresent || actualvalue != entry.Value) { return(false); } break; case "none": //never matches anything. Useful for background color or other special styles that need to exist but don't want to appear normally. return(false); case "default": //Always matches. Can only be on one entry, which is the last entry and the default color return(true); } } //Now, we should have bailed out if any mandatory thing didn't match. Now make sure that we either had 0 OR checks or matched on any OR rule provided. if (OrMatched || orRuleCount == 0) { return(true); } //We did not match an OR clause, so this TPE is not a match. return(false); }
/// <summary> /// Determine if this StyleEntry matches or not against a Place's tags. /// </summary> /// <param name="tpe">The StyleEntry to check</param> /// <param name="tags">the tags for a Place to use</param> /// <returns>true if this StyleEntry applies to this Place's tags, or false if it does not.</returns> public static bool MatchOnTags(StyleEntry tpe, ICollection <PlaceTags> tags) { //NOTE: this cast make this path slightly slower (.01ms), but I don't have to maintain 2 version of this functions full code. return(MatchOnTags(tpe, tags.ToDictionary(k => k.Key, v => v.Value))); }