public styleFourSide(styleTheme _theme, appendType __type) { type = __type; theme = _theme; themeCodeName = _theme.getCodeName(); processType(__type); }
//private void AppendPair(string v1, object p, bool v2, string v3) //{ // throw new NotImplementedException(); //} //public override void open(String tag) //{ // String __op = String.Format(openTagFormat, tag); // AppendLine(linePrefix + tabInsert + __op); // openedTags.Push(tag); //} ///// <summary> ///// Dodaje HTML zatvaranje taga -- zatvara poslednji koji je otvoren ///// </summary> ///// <remarks> ///// Ako je prosledjeni tag none onda zatvara poslednji tag koji je otvoren. ///// </remarks> ///// <param name="tag"></param> //public override void close(String tag = "none") //{ // //tag = tag.checkForDefaultTag(reportOutputRoles.container); // String __cl = String.Format(closeTagFormat, tag); // if (tag == "none") // { // if (openedTags.Any()) // { // tag = openedTags.Pop(); // } // else // { // tag = "error"; // } // } // if (tag != "none") // { // AppendLine(linePrefix + tabInsert + __cl); // } //} /// <summary> /// Appends inline or in new line /// </summary> /// <param name="content">String to add</param> /// <param name="type">Disabled</param> /// <param name="breakLine">On TRUE it will break into new line</param> public void Append(string content, appendType type = appendType.none, bool breakLine = false) { _AppendLine(imbStringCSSExtensions.renderCssBlockForTag(type, content)); //_Append("/* ".a(content).Add(" */")); //Append(content.ensureEndsWith(";"),appendType.none, breakLine); }
/// <summary> /// The most common Append instruction: <see cref="docScriptInstruction"/> class. /// </summary> /// <remarks> /// Applicable with appendType: cite, code, /// </remarks> /// <param name="__type">The type.</param> /// <param name="__input">The input.</param> /// <param name="__isHorizontal">if set to <c>true</c> [is horizontal].</param> public docScriptInstruction(appendType __type, string __input, bool __isHorizontal = false) { type = __type; input = __input; isHorizontal = __isHorizontal; arg(d.dsa_w, 1).arg(d.dsa_h, 1); }
public virtual appendType getAppendType(Int32 x, Int32 y) { appendType output = appendType.regular; throw new NotImplementedException(); // output = getAppendRole(state(x, y)).convertRoleToType(); return(output); }
/// <summary> /// Renders the CSS block for tag. /// </summary> /// <param name="type">The type.</param> /// <param name="content">The content.</param> /// <returns></returns> public static string renderCssBlockForTag(this appendType type, String content) { String output = ""; output.addLine(imbSciStringExtensions.add(toHtmlTagName(type), "{", " ")); output.addLine(content); output.addLine("}"); return(output); }
public styleFourSide getShotSet(appendType type) //, appendType type = appendType.none) { String key = styleFourSide.getCodeName(type, theme); if (!shots.ContainsKey(key)) { styleFourSide tmp = new styleFourSide(theme, type); shots.Add(key, tmp); } return(shots[key]); }
public styleTextShot getShotSet(appendRole role, appendType type = appendType.none) { String key = styleTextShot.getCodeName(role, type, theme); if (!shots.ContainsKey(key)) { styleTextShot tmp = new styleTextShot(role, type, theme); shots.Add(key, tmp); } return(shots[key]); }
internal void processType(appendType __type) { type = __type; switch (type) { case appendType.c_table: setup(0, 25, acePaletteRole.colorDefault, 1, styleBorderType.Thin, styleSideDirection.left, styleSideDirection.right, styleSideDirection.top); setup(0, 25, acePaletteRole.colorDefault, 2, styleBorderType.Double, styleSideDirection.bottom); break; case appendType.c_section: setup(0, 25, acePaletteRole.colorDefault, 2, styleBorderType.Thin, styleSideDirection.left); break; default: break; } }
public override object AppendHeading(string content, int level = 1) { appendType hd = (appendType)appendType.heading + level; Boolean hadTab = (tabLevel > 0); prevTabLevel(); Append(content, hd, true); AppendLine(); if (hadTab) { nextTabLevel(); } //_AppendLine(content.markdownText(hd)); return(""); }
public static styleTextTypeEnum getSubset(this appendType type) { styleTextTypeEnum output = styleTextTypeEnum.none; switch (type) { default: case appendType.bold: case appendType.monospace: case appendType.striketrough: case appendType.squareQuote: case appendType.blockquote: if (Enum.TryParse <styleTextTypeEnum>(output.ToString(), out output)) { return(output); } break; case appendType.marked: return(styleTextTypeEnum.marked); break; case appendType.quotation: case appendType.italic: return(styleTextTypeEnum.italic); break; case appendType.math: case appendType.source: case appendType.sourceCS: case appendType.sourceJS: case appendType.sourcePY: case appendType.sourceXML: return(styleTextTypeEnum.source); break; } return(output); }
/// <summary> /// Converting heading tags into proper markdown /// </summary> /// <param name="tag"></param> /// <param name="content"></param> /// <param name="sb"></param> /// <returns></returns> public static appendType detectMarkdownTagHeading(this String tag) { String prefix = ""; appendType output = appendType.none; tag = tag.ToLower(); if (tag == "h") { return(appendType.heading); } if ((tag.Length == 2) && tag.StartsWith("h")) { Int32 hLevel = (Int32)imbSciStringExtensions.removeStartsWith(tag, "h").imbToNumber(typeof(Int32)); prefix = "heading_" + hLevel.ToString(); Enum.TryParse <appendType>(prefix, out output); } return(output); }
/// <summary> /// Detects proper companion to HTML tag /// </summary> /// <param name="tag"></param> /// <param name="content"></param> /// <param name="sb"></param> /// <returns></returns> public static appendType markdownTag(this String tag, String content, ITextRender sb) { String prefix = tag; appendType type = tag.detectMarkdownStructure(); if (type != appendType.none) { sb.Append(content, type, true); } else { type = detectMarkdownTagHeading(tag); } if (type == appendType.none) { type = appendType.section; } return(type); }
protected appendType executeOnce(docScriptInstruction ins, appendTypeKind kind) { // log("--- execution method: " + kind.ToString()); appendType output = ins.type; if (!settings.supportedAppends.Contains(ins.type)) { log("Ignoring instruction: {0} ({2}) -- not supported by builder: {1}".f(ins.type.ToString(), render.GetType().Name, kind.ToString())); return(ins.type); } if (output != appendType.none) { output = runSpecialInstruction(ins); } if (output != appendType.none) { output = runOtherInstruction(ins); } return(output); }
//public selectRangeArea getRowArea(Int32 y) //{ // cursorVariatorState currentState = state(area.x, y); // appendRole role = getAppendRole(currentState); // return output; //} #pragma warning disable CS1574 // XML comment has cref attribute 'appendType' that could not be resolved /// <summary> /// Provides complete <see cref="styleShotSet"/> according to x,y coordinates and desired <see cref="aceCommonTypes.enums.appendType"/>. /// </summary> /// <param name="x">X (horizontal) position relative to <c>selectRangeArea</c> 0,0 point.</param> /// <param name="y">Y (vertical) position relative to <c>selectRangeArea</c> 0,0 point.</param> /// <param name="type">If <c>appendType.none</c> it will automatically find the best match</param> /// <returns></returns> public styleShotSet getStyleShot(Int32 x, Int32 y, appendType type = appendType.none) #pragma warning restore CS1574 // XML comment has cref attribute 'appendType' that could not be resolved { cursorVariatorState currentState = state(x, y); appendRole role = getAppendRole(currentState); if (type == appendType.none) { throw new NotSupportedException("appendType is set to none!"); //type = role.convertRoleToType(); } acePaletteRole colorToUse = mainPaletteRole; if (currentState.useLayoutPalette) { colorToUse = layoutPaletteRole; } styleShotSet output = new styleShotSet(role, type, (acePaletteVariationRole)currentState.useColorIndex, colorToUse, currentState.useInvertedForeground, theme); return(output); }
/// <summary> /// Converts <c>role</c> into <c>appendType</c> /// </summary> /// <param name="__role">The role.</param> /// <param name="__overrideResult">If not <c>none</c> it will override any conversion and return this as result</param> /// <param name="__defaultType">The default append Type to return if no rule is applicable.</param> /// <returns></returns> public static appendType convertRoleToType(this appendRole __role, appendType __overrideResult = appendType.none, appendType __defaultType = appendType.regular) { //appendType type = appendType.heading; //acePaletteVariationRole varRole = acePaletteVariationRole.normal; Boolean setType = (__overrideResult == appendType.none); appendType type = __defaultType; if (!setType) { type = __overrideResult; return(type); } switch (__role) { case appendRole.none: // type = appendType.regular; break; case appendRole.mergedHead: type = appendType.bold; break; case appendRole.mergedContent: type = appendType.regular; break; case appendRole.mergedFoot: type = appendType.italic; break; case appendRole.sectionHead: type = appendType.bold; break; case appendRole.sectionContent: type = appendType.regular; break; case appendRole.sectionFoot: type = appendType.italic; break; case appendRole.majorHeading: type = appendType.heading_1; break; case appendRole.minorHeading: type = appendType.heading_3; break; case appendRole.paragraph: type = appendType.paragraph; break; case appendRole.remark: type = appendType.italic; break; case appendRole.tableHead: type = appendType.bold; break; case appendRole.tableColumnHead: type = appendType.regular; break; case appendRole.tableColumnFoot: type = appendType.italic; break; case appendRole.tableCellValue: type = appendType.regular; break; case appendRole.tableCellAnnotation: type = appendType.comment; break; case appendRole.tableCellNovalue: // type = appendType.none; break; case appendRole.tableBetween: type = appendType.regular; break; case appendRole.tableFoot: type = appendType.italic; break; default: //type = appendType.regular; //throw new ArgumentOutOfRangeException(); break; } return(type); }
/// <summary> /// Returns appendTypeKind according to appendType /// </summary> /// <param name="type">The type.</param> /// <returns>Proper kind of append</returns> public static appendTypeKind getAppendTypeKind(this appendType type) { switch (type) { case appendType.none: case appendType.bypass: return(appendTypeKind.none); break; case appendType.c_data: case appendType.c_pair: case appendType.c_table: case appendType.c_link: case appendType.c_section: case appendType.footnote: case appendType.section: case appendType.c_open: case appendType.c_close: case appendType.c_line: return(appendTypeKind.complex); break; case appendType.source: case appendType.sourceCS: case appendType.sourceJS: case appendType.sourcePY: case appendType.sourceXML: case appendType.squareQuote: case appendType.striketrough: case appendType.subscript: case appendType.superscript: case appendType.comment: case appendType.blockquote: case appendType.bold: case appendType.heading: case appendType.heading_1: case appendType.heading_2: case appendType.heading_3: case appendType.heading_4: case appendType.heading_5: case appendType.heading_6: case appendType.italic: case appendType.marked: case appendType.math: case appendType.monospace: case appendType.paragraph: case appendType.quotation: case appendType.regular: return(appendTypeKind.simple); break; case appendType.i_chart: case appendType.i_external: case appendType.i_load: case appendType.i_page: case appendType.i_document: case appendType.i_meta: case appendType.i_function: case appendType.i_log: case appendType.x_directory: case appendType.x_save: case appendType.x_scopeIn: case appendType.x_scopeOut: case appendType.x_openTool: case appendType.x_export: case appendType.x_move: case appendType.x_data: case appendType.i_dataSource: case appendType.i_dataInDocument: case appendType.s_style: return(appendTypeKind.special); break; case appendType.s_alternate: case appendType.s_normal: case appendType.s_palette: case appendType.s_width: case appendType.s_variation: case appendType.s_zone: return(appendTypeKind.style); break; break; break; default: String name = type.ToString(); if (name.StartsWith("i_")) { return(appendTypeKind.special); } if (name.StartsWith("x_")) { return(appendTypeKind.special); } if (name.StartsWith("s_")) { return(appendTypeKind.style); } if (name.StartsWith("c_")) { return(appendTypeKind.complex); } return(appendTypeKind.other); break; } return(appendTypeKind.other); }
/// <summary> /// Appends inline or new line content /// </summary> /// <param name="content">String content to be wrapped into container</param> /// <param name="type">Container type - for text it is always none</param> /// <param name="breakLine">Inline (FALSE) or new line (TRUE)</param> public override void Append(String content, appendType type = appendType.none, Boolean breakLine = false) { base._Append(content.markdownText(type), breakLine); }
/// <summary> /// Styling information based on <c>appendType</c> and <c>styleTheme</c> /// </summary> /// <param name="type">The type.</param> /// <param name="theme">The theme.</param> public styleTextShot(appendType type, styleTheme theme) { processType(type, theme); themeCodeName = theme.getCodeName(); }
//public styleTextShot(appendType type, styleTheme theme) //{ // this.type = type; // this.theme = theme; //} /// <summary> /// Processes the <c>appendType</c> and <c>styleTheme</c> to define all styling information /// </summary> /// <param name="__type">The type.</param> /// <param name="theme">The theme.</param> internal void processType(appendType __type, styleTheme theme) { type = __type; sizeEnum = imbStringMarkdownExtensions.getTextSizeEnum(type); fontStyle = new FontStyle(); if (theme.fontSize.isThisHeading(sizeForFont)) { font = theme.fontForHeadings.drawingFont; } else { font = theme.fontForText.drawingFont; } sizeForFont = theme.fontSize.headingSizes[sizeEnum.ToInt32()]; doCallForInverse = theme.fontSize.isThisMajorHeading(sizeEnum); switch (type) { case appendType.squareQuote: fontStyle = FontStyle.Italic | FontStyle.Underline; break; case appendType.blockquote: fontStyle = FontStyle.Italic | FontStyle.Bold; break; case appendType.marked: fontStyle = FontStyle.Underline; break; case appendType.quotation: case appendType.italic: fontStyle = FontStyle.Italic; break; case appendType.bold: fontStyle = FontStyle.Bold; break; case appendType.monospace: fontStyle = FontStyle.Regular; //target.Font.SetFromFont(System.Drawing.SystemFonts.DefaultFont); break; case appendType.math: case appendType.source: case appendType.sourceCS: case appendType.sourceJS: case appendType.sourcePY: case appendType.sourceXML: break; case appendType.striketrough: fontStyle = FontStyle.Strikeout; break; case appendType.comment: modification = styleTextModificationEnum.smaller; break; } }
internal void processRole(appendRole __role, appendType __type, styleTheme theme) { role = __role; type = __type; Int32 sizeKWidth = 8; Int32 sizeKHeight = 1; themeCodeName = theme.getCodeName(); var sizeEnum = imbStringMarkdownExtensions.getTextSizeEnum(__type); var size = theme.fontSize.headingSizes[sizeEnum.ToInt32()]; fourSideSetting margin = theme.fontSize.headingMargins[sizeEnum.ToInt32()]; fourSideSetting padding = theme.fontSize.headingPaddings[sizeEnum.ToInt32()]; sizeAndBorder.apply(margin, styleFourSideParameter.margin); sizeAndBorder.apply(padding, styleFourSideParameter.padding); String roleName = role.ToString(); aligment = textCursorZoneCorner.Left; if (roleName.StartsWith("merged")) { doWrapText = true; doCallForMerge = true; } if (roleName.StartsWith("section")) { doWrapText = true; } if (roleName.EndsWith("Head")) { aligment = textCursorZoneCorner.center; sizeAndBorder.bottom.type = styleBorderType.Thin; } if (roleName.EndsWith("Foot")) { aligment = textCursorZoneCorner.Left; sizeAndBorder.top.type = styleBorderType.Thin; } switch (role) { case appendRole.none: break; case appendRole.mergedHead: break; case appendRole.mergedContent: break; case appendRole.mergedFoot: break; case appendRole.sectionHead: break; case appendRole.sectionContent: break; case appendRole.sectionFoot: break; case appendRole.majorHeading: break; case appendRole.minorHeading: break; case appendRole.paragraph: break; case appendRole.remark: break; case appendRole.tableHead: sizeAndBorder.top.type = styleBorderType.Double; doWrapText = true; doCallForMerge = true; break; case appendRole.tableColumnHead: doWrapText = true; break; case appendRole.tableColumnFoot: sizeAndBorder.top.type = styleBorderType.Dotted; break; case appendRole.tableCellValue: break; case appendRole.tableCellAnnotation: sizeAndBorder.top.type = styleBorderType.Dotted; sizeAndBorder.bottom.type = styleBorderType.Dotted; break; case appendRole.tableCellNovalue: break; case appendRole.tableBetween: sizeAndBorder.top.type = styleBorderType.Dotted; sizeAndBorder.bottom.type = styleBorderType.Dotted; break; case appendRole.tableFoot: sizeAndBorder.bottom.type = styleBorderType.Double; break; case appendRole.i_container: break; case appendRole.i_margin: sizeKHeight = 1; sizeKWidth = 1; break; case appendRole.i_line: break; default: break; } minSize = new styleSize(size * sizeKWidth, size * sizeKHeight); minSize.width += sizeAndBorder.left.padding + sizeAndBorder.right.padding; minSize.height += sizeAndBorder.top.padding + sizeAndBorder.bottom.padding; }
/// <summary> /// Returns html tag name for appendType /// </summary> /// <param name="type"></param> /// <returns>only textual part of html tag</returns> public static string toHtmlTagName(this appendType type) { //if (type != appendType.bypass) content = content.markdownEscape(); switch (type) { case appendType.blockquote: return("blockquote"); break; case appendType.bold: return("b"); break; case appendType.italic: return("i"); break; case appendType.monospace: return("kbd"); break; case appendType.striketrough: return("s"); break; case appendType.subscript: return("sub"); break; case appendType.superscript: return("sup"); break; case appendType.marked: return("mark"); break; case appendType.squareQuote: return("em"); break; case appendType.heading: return("h1"); case appendType.heading_1: return("h1"); case appendType.heading_2: return("h2"); break; case appendType.heading_3: return("h3"); break; case appendType.heading_4: return("h4"); break; case appendType.heading_5: return("h5"); break; case appendType.heading_6: return("h6"); break; case appendType.math: return("summary"); case appendType.quotation: return("q"); case appendType.source: return("code"); break; case appendType.sourceJS: return("script"); break; case appendType.sourcePY: return("code"); break; case appendType.sourceCS: return("code"); break; case appendType.sourceXML: return("code"); // "```xml".addLine(content).addLine("```"); break; case appendType.paragraph: return("p"); break; case appendType.section: // String prefix = Environment.NewLine; // prefix += Environment.NewLine; return("section"); break; case appendType.regular: return("span"); break; default: return("p"); break; } //sb.AppendLine(linePrefix + tabInsert + content.ToUpper()); }
/// <summary> /// Inverse call for markdownText extension /// </summary> /// <param name="type"></param> /// <param name="content">Content</param> /// <returns>Markdown code</returns> public static String plainText(this appendType type, String content) { return(content.plainText(type)); }
/// <summary> /// Requires immediate <c>set()</c> call to set values for arguments /// </summary> /// <param name="__type">The type.</param> /// <param name="__arguments">The arguments.</param> public docScriptInstruction(appendType __type, params docScriptArguments[] __arguments) { args = __arguments.getFlatList <docScriptArguments>(); type = __type; }
/// <summary> /// Deploying markdown wrapping syntax /// </summary> /// <param name="content"></param> /// <param name="type"></param> /// <returns></returns> public static string plainText(this String content, appendType type) { if (type != appendType.bypass) { content = content.markdownEscape(); } switch (type) { case appendType.marked: return("" + content + "[*]"); break; case appendType.squareQuote: return("<<" + content + ">>"); break; case appendType.heading: case appendType.heading_1: case appendType.heading_2: return(content.ToUpper()); break; case appendType.quotation: return(imbSciStringExtensions.add(imbSciStringExtensions.add("\"", content, ""), "\"", "")); case appendType.sourceXML: case appendType.sourceCS: case appendType.sourcePY: case appendType.sourceJS: case appendType.source: return(imbSciStringExtensions.add(imbSciStringExtensions.add("[code]", content, ""), "[/code]", "")); case appendType.paragraph: return(Environment.NewLine.addLine(content)); break; case appendType.section: String prefix = Environment.NewLine; prefix += Environment.NewLine; //return " > ".addLine(content); break; case appendType.regular: return(content); break; default: return(content); break; } return(content); //sb.AppendLine(linePrefix + tabInsert + content.ToUpper()); }
public static String getCodeName(appendRole __role, appendType __type, styleTheme theme) { return(__role.ToString() + "_" + __type.ToString() + "_" + theme.getCodeName()); }
/// <summary> /// Executes the and save. /// </summary> /// <param name="report">The report.</param> /// <param name="runstamp">The runstamp.</param> /// <param name="__data">The data.</param> protected void execute(metaDocumentRootSet report, string runstamp, PropertyCollection __data = null) { dataDictionary = new PropertyCollectionDictionary(); if (!unit.scriptFlags.HasFlag(docScriptFlags.disableGlobalCollection)) { logStartPhase("Collect data", "#2 phase of data collecting"); dataDictionary = report.collect(dataDictionary); logEndPhase(); } else { log("Global data collection disabled by unit.scriptFlags"); } logStartPhase("Script composing", "#3 phase of data composing"); script = new docScript("Script - unit[" + unit.name + "] - runstamp: " + runstamp); script.flags = unit.scriptFlags; script = report.compose(script); if (doBuildDeliveryMeta) { string scMeta = script.ToString(docScriptInstructionTextFormatEnum.meta); scMeta.saveStringToFile(directoryRoot.FullName.add("deliveryMeta.md", "\\"), getWritableFileMode.autoRenameExistingOnOtherDate, Encoding.UTF8); string csMeta = script.ToString(docScriptInstructionTextFormatEnum.cs_compose); csMeta.saveStringToFile(directoryRoot.FullName.add("deliveryMeta.cs", "\\"), getWritableFileMode.autoRenameExistingOnOtherDate, Encoding.UTF8); } logEndPhase(); setup(unit.theme, data, renders.getTextRenders()); logStartPhase("Script compilation", "#4 applying data to content"); compiled = compile(script, dataDictionary); repo = new reportOutputRepository(directoryRoot, script.name); logStartPhase("Execute docScriptInstructions ", "5# executing scripttotal instructions (" + script.Count() + ")"); index = 0; int tIndex = 1000; int mediumTimerLimit = 10; int mediumTimerIndex = 0; foreach (docScriptInstructionCompiled instruction in compiled) { try { appendTypeKind kind = instruction.type.getAppendTypeKind(); if (doVerboseLog) { log(index.ToString("D4") + " " + instruction.ToString(docScriptInstructionTextFormatEnum.meta)); } //afinal = appendType.none; appendType final = executeOnce(instruction, kind); if (final != appendType.none) { final = runStyleInstruction(instruction); } if (final == appendType.none) { } else { var scopeLevel = scope.elementLevel; foreach (var it in unit.outputByLevel[scopeLevel]) { deliveryUnitItemSimpleRenderOutput output = it as deliveryUnitItemSimpleRenderOutput; if (output != null) { output.executeScriptInstruction(this, instruction); final = appendType.none; // builder = output.builder; } } } if (executionStopFlagCheck()) { log("Execution is stopped by executionStopFlag!"); break; } index++; } catch (Exception ex) { string msg = Environment.NewLine + "Report script execution [" + index + "/" + compiled.Count() + "] error. Instruction: [" + instruction.ToString(docScriptInstructionTextFormatEnum.cs_compose) + "]"; msg = msg.addLine("-- scoped meta object: path:[" + scope.path + "] -- [" + scope.name + "] -- [" + scope.GetType().Name + "]"); msg = msg.addLine("-- directory: [" + directoryScope.FullName + "]"); msg = msg.addLine("-- exception: [" + ex.GetType().Name + "] => [" + ex.Message + "]"); var axe = new aceReportException(msg + "Report instruction [" + instruction.type.ToString() + "] exception"); //if (axe.callInfo != null) //{ // msg = msg.addLine("-- source of ex: [" + axe.callInfo.sourceCodeLine + "]"); // msg = msg.addLine("-- source file: [" + axe.callInfo.Filepath + "]"); // msg = msg.addLine("-- source line: [" + axe.callInfo.line + "]"); // msg = msg.addLine("-- source class: [" + axe.callInfo.className + "]"); //} log(msg + Environment.NewLine); string path = "errorReport_" + index.ToString() + ".txt"; path = directoryScope.FullName.add(path, "\\"); msg.saveStringToFile(path, getWritableFileMode.autoRenameExistingOnOtherDate, Encoding.UTF8); if (errorPolicy.doThrow()) { throw axe; } executionError("Internal exception during an instruction execution", instruction, ex); } #region ---------------------------------- if (compiled.Count() > 1000) { if (tIndex > 0) { tIndex--; } else { mediumTimerIndex++; double ratio = ((double)index) / ((double)compiled.Count()); aceLog.log("Report generation at [" + ratio.ToString("P") + "] done"); tIndex = 1000; } } if (mediumTimerIndex > mediumTimerLimit) { var memBefore = GC.GetTotalMemory(false); GC.Collect(); var memBefore2 = memBefore - GC.GetTotalMemory(false); aceLog.log("-- garbage collector invoked - memory released: " + memBefore2.getMByteCountFormated()); // aceLog.saveAllLogs(true); mediumTimerIndex = 0; } #endregion ---------------------------------- } GC.Collect(); GC.WaitForFullGCComplete(); logEndPhase(); AppendPairs(data, false, " -> "); log("Completed"); foreach (IDeliveryUnitItem item in unit.items) { item.reportFinishedOperation(this); } // aceLog.consoleControl.removeFromOutput(this); }
/// <summary> /// The prefered way of obtaining style information /// </summary> /// <param name="role">The role of particular append</param> /// <param name="__type">The type of particular append</param> /// <param name="theme">The theme to use fonts and size settings from</param> public styleTextShot(appendRole role, appendType __type, styleTheme theme) { processRole(role); processType(__type, theme); themeCodeName = theme.getCodeName(); }
public static String getCodeName(appendType __type, styleTheme theme) { return(imbSciStringExtensions.add(__type.ToString(), theme.getCodeName(), "-")); }
public styleShotSet(appendRole role, appendType type, acePaletteVariationRole colorRole, acePaletteRole paletteRole, Boolean isInverse, styleTheme theme) { palette = theme.palletes.getShotSet(colorRole, isInverse, paletteRole); text = theme.textShotProvider.getShotSet(role, type); container = theme.styleContainerProvider.getShotSet(role, type); }
public styleContainerShot(appendRole __role, appendType __type, styleTheme theme) { processRole(__role, __type, theme); }