/// <summary> /// Renders a content object into an boolean matrix; /// while <c>true</c> values indicating raised pins and <c>false</c> values indicating lowered pins /// </summary> /// <param name="view">The frame to render in. This gives access to the space to render and other parameters. Normally this is a BrailleIOViewRange/>.</param> /// <param name="content">The content to render.</param> /// <param name="callHooks">if set to <c>true</c> [call the pre- and post-rendering hooks].</param> /// <returns> /// A two dimensional boolean M x N matrix (bool[M,N]) where M is the count of rows (this is height) /// and N is the count of columns (which is the width). /// Positions in the Matrix are of type [i,j] /// while i is the index of the row (is the y position) /// and j is the index of the column (is the x position). /// In the matrix <c>true</c> values indicating raised pins and <c>false</c> values indicating lowered pins /// </returns> public override bool[,] RenderMatrix(IViewBoxModel view, object content, bool callHooks = true) { if (view != null && content != null) { if (callHooks) { callAllPreHooks(ref view, ref content); } bool renderScrollbars = view is IPannable ? ((IPannable)view).ShowScrollbars : false; int width = view.ContentBox.Width; int height = view.ContentBox.Height; bool scrolleBars = renderScrollbars && EstimateNeedOfScrollBar(content as String, width, height); var matrix = RenderMatrix(width, content, scrolleBars); // rerender if scrollbars were needed if (renderScrollbars && !scrolleBars && matrix.GetLength(0) > height) { matrix = RenderMatrix(width, content, true); } view.ContentHeight = matrix.GetLength(0); view.ContentWidth = matrix.GetLength(1); if (callHooks) { callAllPostHooks(view, content, ref matrix); } return(matrix); } return(new bool[1, 1]); }
/// <summary> /// Determines whether the entry is visible or not. /// </summary> /// <param name="renderedEntry">The rendered entry.</param> /// <param name="view">The view to check for (BrailleIoViewRange).</param> /// <returns> /// -1 if not visible; 0 if party visible, and 1 if fully visible. /// </returns> public virtual int IsEntryVisible(RenderElement renderedEntry, IViewBoxModel view = null) { if (!renderedEntry.IsEmpty()) { if (view == null) { view = _lastView; } if (view != null && view.ContentBox.Width * view.ContentBox.Height > 0) { int left, top, right, bottom; left = top = 0; if (view is IPannable) { left = ((IPannable)view).GetXOffset(); top = ((IPannable)view).GetYOffset(); } right = view.ContentBox.Width + left; bottom = view.ContentBox.Height + top; if (renderedEntry.IsInArea(left, left + right, top, top + bottom)) { if (renderedEntry.IsCompletelyInArea(left, right, top, bottom)) { return(1); } return(0); } } } return(-1); }
/// <summary> /// Draws scrollbars in the viewMatrix. /// </summary> /// <param name="view">The view.</param> /// <param name="viewMatrix">The view matrix.</param> /// <param name="xOffset">The x offset.</param> /// <param name="yOffset">The y offset.</param> /// <param name="paintArrows">if set to <c>true</c> [paint arrows].</param> /// <returns></returns> public static bool DrawScrollbars(IViewBoxModel view, ref bool[,] viewMatrix, int xOffset, int yOffset, bool paintArrows = false) { AbstractViewBoxModelBase vb = view as AbstractViewBoxModelBase; if (vb != null) { if (vb.GetXOffset() != 0) { xOffset = vb.GetXOffset(); } if (vb.GetYOffset() != 0) { yOffset = vb.GetYOffset(); } } bool vertical = false; if (view.ContentBox.Height < view.ContentHeight) { vertical = true; drawVerticalScrollBar(view, ref viewMatrix, yOffset, (view.ContentBox.Height < 8 ? true : paintArrows)); } if (view.ContentBox.Width < view.ContentWidth) { drawHorizontalScrollBar(view, ref viewMatrix, xOffset, vertical, (view.ContentBox.Width < 8 ? true : paintArrows)); } return(true); }
/*Builds the text matrix with cursor if needed.*/ private bool[,] buildTextMatrix(IViewBoxModel view) { bool[,] renderedText = emptyMatrix; if (view != null) { //Renders the InputBox content renderedText = textRenderer.RenderTitleMatrix(view, editFieldEntry, boxProperties.LineContentWidth, boxProperties.LineCount, boxProperties.CharsPerLine, titleHasChanged); //If EditField is activated, the cursor will be rendered into the content matrix if (editFieldEntry.Status.HasFlag(DialogEntryStatus.Editing) && cursorRenderer.ShowCursorForBlinking) { int position = editFieldEntry.GetCursorPosition(); //Adjust CursorPosition for Rendereing if (editFieldEntry.InputBox.BoxHeightType == BoxHeightTypes.SingleLine || editFieldEntry.InputBox.MinimizeType == MinimizeTypes.AlwaysMinimize) { //Position has a shifting due to dots infront/after SingleLine Text position = position - textRenderer.GetLastSegmentIndex() + textRenderer.GetPositionOffset(); } //Position has a shifting due to line breaks that might ignore spaces in next lines else if (boxProperties.LineCount != null && boxProperties.LineCount > 1) { position = getCharPositionsAfterLineBreaks(renderedText, position, editFieldEntry.Title); } renderedText = cursorRenderer.renderCursorIntoTitleMatrix(renderedText, editFieldEntry, position, cursorHasChanged); //renderedText = renderCursorIntoTitleMatrix(renderedText, position); } } return(renderedText); }
/// <summary> /// Renders the breadcrumb menu. /// </summary> /// <param name="view">The view.</param> /// <param name="activeDialog">The active dialog.</param> /// <param name="renderedEntries">The rendered entries list for touch interaction.</param> protected virtual bool renderBreadcrumbMenu(IViewBoxModel view, Dialog activeDialog, ref List <RenderedDialogEntry> renderedEntries) { if (TitleRenderer != null) { var tm = TitleRenderer.RenderMatrix(view, activeDialog); if (tm != null && !tm.Equals(emptyMatrix)) { IList <RenderElement> rE = TitleRenderer is BreadcrumbRenderer ? ((BreadcrumbRenderer)TitleRenderer).GetAllRenderElements() : TitleRenderer is ITouchableRenderer ? ((ITouchableRenderer)TitleRenderer).GetAllContentInArea(0, tm.GetLength(1), 0, tm.GetLength(0)) as IList <RenderElement> : null; renderedEntries.Add(new RenderedDialogEntry(tm, rE)); renderedEntries.Add(onePinSpacerEntry); // spacing renderedEntries.Add(getSolidDividerEntry(view.ContentBox.Width)); // separation // renderedEntries.Add(getSolidDividerEntry(view.ContentBox.Width)); // separation renderedEntries.Add(onePinSpacerEntry); // spacing return(true); } } return(false); }
/// <summary> /// Informs the renderer that the content the or view has changed. /// You have to call the PrerenderMatrix function manually if you want to have a cached result. /// </summary> /// <param name="view">The view.</param> /// <param name="content">The content.</param> public virtual void ContentOrViewHasChanged(IViewBoxModel view, object content) { string viewString = viewToString(view); // if (!ViewBoxModelEquals(lastView, view)) contentOrViewHasChanged(viewString, content); }
private void calculateLineWidth(IViewBoxModel view4rendering) { if (view4rendering != null) { LineWidth = view4rendering.ContentBox.Width - SCROLLBAR_WIDTH; } }
/// <summary> /// Renders a content object into an boolean matrix; /// while <c>true</c> values indicating raised pins and <c>false</c> values indicating lowered pins /// </summary> /// <param name="view">The frame to render in. This gives access to the space to render and other parameters. Normally this is a BrailleIOViewRange.</param> /// <param name="content">The content to render.</param> /// <returns> /// A two dimensional boolean M x N matrix (bool[M,N]) where M is the count of rows (this is height) /// and N is the count of columns (which is the width). /// Positions in the Matrix are of type [i,j] /// while i is the index of the row (is the y position) /// and j is the index of the column (is the x position). /// In the matrix <c>true</c> values indicating raised pins and <c>false</c> values indicating lowered pins /// </returns> public bool[,] RenderMatrix(IViewBoxModel view, object content) { callAllPreHooks(ref view, ref content, null); if (!ViewBoxModelEquals(lastView, view)) { ContentOrViewHasChanged(view, content); } else if (!lastContent.Equals(content)) { ContentOrViewHasChanged(view, content); } if (ContentChanged) { _cachedMatrix = RenderMatrix(view, content, CallHooksOnCacherendering); LastRendered = DateTime.Now; ContentChanged = false; } bool[,] output = GetCachedMatrix().Clone() as bool[, ]; callAllPostHooks(view, content, ref output, null); return(output); }
// Result is addressed in [y, x] notation. void IBailleIORendererHook.PostRenderHook(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { if (Active && DoRenderBoundingBox && WindowManager.Instance != null && !WindowManager.Instance.IsInMinimapMode()) { doBlinkingBoundingBox(view, content, ref result, additionalParams); } }
/// <summary> /// Gets the page bounds in view range. /// </summary> /// <param name="view">The view the page is presented in.</param> /// <param name="pagePosOnScreen">The page bounds on the screen in pixels.</param> /// <returns>The page bounds in the content of the view range in pins.</returns> public static Rectangle GetPageBoundsInViewRange(IViewBoxModel view, Rectangle pagePosOnScreen) { // make the document bounds relative to the chosen zoom level double zoom = view is BrailleIO.Interface.IZoomable ? zoom = ((BrailleIO.Interface.IZoomable)view).GetZoom() : 1; if (((BrailleIOViewRange)view).Name.Equals(WindowManager.VR_CENTER_NAME) && ((BrailleIOViewRange)view).Parent.Name.Equals(WindowManager.BS_MINIMAP_NAME)) { if (WindowManager.Instance != null) { zoom = WindowManager.Instance.MinimapScalingFactor; // handling for minimap mode } } Rectangle zPos = new Rectangle( (int)(pagePosOnScreen.X * zoom), (int)(pagePosOnScreen.Y * zoom), (int)(pagePosOnScreen.Width * zoom), (int)(pagePosOnScreen.Height * zoom) ); // add the panning offsets if (view is IPannable) { zPos.X += ((IPannable)view).GetXOffset(); zPos.Y += ((IPannable)view).GetYOffset(); } return(zPos); }
public void PostRenderHook(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { if (view != null && content != null && result != null) { if (!String.IsNullOrEmpty(selectedString) && content.ToString().ToLower().Contains(selectedString.ToLower())) { int start = content.ToString().ToLower().IndexOf(selectedString.ToLower()); //check int end = start + selectedString.Length; start = start * 3; // each letter has 3 dot * 5 end = end * 3; int underlinePos = 4; // underline 4 & 8 for (int i = start; i < end; i++) { if (result.GetLength(0) > underlinePos) { if (result.GetLength(1) > i) { result[underlinePos, i] = true; } } } } } }
/// <summary> /// Renders the label. /// </summary> /// <param name="entry">The entry.</param> /// <param name="view">The view.</param> /// <returns></returns> public bool[,] RenderLabel(EditField_DialogEntry entry, IViewBoxModel view) { bool[,] labelMatrix = emptyMatrix; if (cachedLabelMatrix == null) { if (view != null && entry != null && entry.HasLabel) { string titleBackup = entry.Title; this.Entry.Title = entry.Label; labelMatrix = renderDialogEntry(view); cachedLabelMatrix = labelMatrix; this.Entry.Title = titleBackup; lastLabel = entry.Label; } } else { labelMatrix = (bool[, ])cachedLabelMatrix.Clone(); } return(labelMatrix); }
/*Builds the cached matrix consisting out of edges, borders, title and cursor. * Parts will be rendered new depending on changes on runtime. * If entry is NOT graphical, boders and edges will not be rendered.*/ private bool[,] buildContentMatrix(IViewBoxModel view) { bool[,] boxMatrix = emptyMatrix; if (view != null && editFieldEntry != null && editFieldEntry.Title != null) { //Renders the field text, if needed with cursor bool[,] renderedText = buildTextMatrix(view); //Renders Box that will contain text. If Graphical, it gets borders and edges. If Not, it will have enough // space for an indenting and will get 1 extra pin line to seperate label and content boxMatrix = boxRenderer.RenderBoxMatrix(boxProperties.BoxDimensions, borderOrEdgeHaveChanged, editFieldEntry.InputBox.IsGraphical, EditField_BoxProperties.BORDER_THICKNESS); //if editFieldEntry.Title is not empty, fill the box matrix with text matrix if (editFieldEntry.Title.Length > 0 || editFieldEntry.Status.HasFlag(DialogEntryStatus.Editing)) { boxMatrix = fillBoxMatrixWithTextMatrix(boxMatrix, renderedText); } lastView = view; lastTitle = Entry.Title; lastCursorPosition = editFieldEntry.GetCursorPosition(); lastIsMinimized = editFieldEntry.InputBox.IsMinimized; } return(boxMatrix); }
// Result is addressed in [y, x] notation. void IBailleIORendererHook.PostRenderHook(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { if (Active && _doRenderBoundingBox && WindowManager.Instance != null && !WindowManager.Instance.IsInMinimapMode()) { doBlinkingBoundingBox(view, content, ref result, additionalParams); } }
/// <summary> /// Renders a content object into an boolean matrix; /// while <c>true</c> values indicating raised pins and <c>false</c> values indicating lowered pins /// </summary> /// <param name="view">The frame to render in. This gives access to the space to render and other parameters. Normally this is a IBrailleIOViewRange.</param> /// <param name="content">The content to render.</param> /// <returns> /// A two dimensional boolean M x N matrix (bool[M,N]) where M is the count of rows (this is height) /// and N is the count of columns (which is the width). /// Positions in the Matrix are of type [i,j] /// while i is the index of the row (is the y position) /// and j is the index of the column (is the x position). /// In the matrix <c>true</c> values indicating raised pins and <c>false</c> values indicating lowered pins /// </returns> public bool[,] RenderMatrix(IViewBoxModel view, object content) { bool[,] m = emptyMatrix; if (content != null && content is Dialog && view != null) { Dialog activeDialog = ((Dialog)content).GetActiveDialog(); if (activeDialog != null) { List <RenderedDialogEntry> renderedEntries = new List <RenderedDialogEntry>(); if (Properties.HasFlag(DialogRenderingProperties.HideEntries)) { //////// BREADCRUMB ////// if (Properties.HasFlag(DialogRenderingProperties.ShowHeader)) { renderBreadcrumbMenu(view, activeDialog, ref renderedEntries); } } else { /////////// HELP //////////// if (activeDialog.HelpIsShown) { m = renderHelp(view, activeDialog); } ////////// NORMAL ////////// else { //////// BREADCRUMB ////// if (Properties.HasFlag(DialogRenderingProperties.ShowHeader)) { renderBreadcrumbMenu(view, activeDialog, ref renderedEntries); } //////// ENTRIES ////// renderDialogEntries(view, activeDialog, ref renderedEntries); } } // build them together if (renderedEntries != null && renderedEntries.Count > 0) { m = combineEntries(renderedEntries); } view.ContentHeight = m.GetLength(0); view.ContentWidth = m.GetLength(1); // check if scrollbars are needed if (view.ContentHeight > view.ContentBox.Height) { view.ContentWidth -= 3; // cut of the overlapping line elements. Text content is rendered with respect of scrollbar space } } } _lastView = view; return(m); }
/// <summary> /// Informs the renderer that the content the or view has changed. /// You have to call the PrerenderMatrix function manually if you want to have a cached result. /// </summary> /// <param name="view">The view.</param> /// <param name="content">The content.</param> public virtual void ContentOrViewHasChanged(IViewBoxModel view, object content) { if (!ViewBoxModelEquals(lastView, view)) { lastView = view; //Clone(view); } lastContent = content; ContentChanged = true; }
/// <summary> /// Initializes a new instance of the <see cref="DummyViewBox"/> class. /// </summary> /// <param name="baseModel">The base model this dummy is copied from.</param> public DummyViewBox(IViewBoxModel baseModel) { if (baseModel != null) { _contentBox = baseModel.ContentBox; _viewBox = baseModel.ViewBox; _cWidth = baseModel.ContentWidth; _cHeight = baseModel.ContentHeight; } }
/// <summary> /// Calculates the height of the line content. /// </summary> /// <param name="view4rendering">The view4rendering.</param> public void CalculateLineContentHeight(IViewBoxModel view4rendering) { if (view4rendering != null && LineCount > 0) { /* * All char heights view4rendering.ContentHeight * LineCount * one line space between multiple lines (LineCount - 1) * */ LineContentHeight = CHAR_HEIGHT * LineCount + (LineCount - 1) + (2 * BORDER_THICKNESS); } }
public bool[,] RenderImage(Bitmap img, IViewBoxModel view, IPannable offset, bool invert, double zoom, bool autoThreshold) { // FIXME: check this (invalidoperationexception nach schwellwert mehrmals absenken) var vr = view.ContentBox; Bitmap img2 = img.Clone() as Bitmap; if (img2 != null) { return(RenderImage(img2, view, offset, invert, zoom, GraphicUtils.GetAverageGrayscale(vr.Width, vr.Height, new Bitmap(img2, new Size((int)Math.Round(img2.Width * zoom), (int)Math.Round(img2.Height * zoom)))))); } return(null); }
/// <summary> /// Calculates the box properties. /// </summary> /// <param name="view">The view.</param> /// <param name="entry">The entry.</param> public void CalculateBoxProperties(IViewBoxModel view, EditField_DialogEntry entry) { if (view != null && entry != null) { calculateLineWidth(view); calculateLineContentWidth(); calculateCharsPerLine(); CalculateLineCount(entry); CalculateLineContentHeight(view); CalculateBoxDimensions(view, entry); } }
/// <summary> /// estimate if scrollbars are needed or not /// </summary> /// <param name="view">The view to show the content in.</param> /// <param name="dialog">The dialog to display.</param> /// <returns><c>true</c> if scrollbars are needed; otherwise <c>false</c>.</returns> bool needScrollbars(IViewBoxModel view, Dialog dialog) { if (view != null && view.ContentBox.Height > 0 && dialog != null) { if (view is IPannable && !((IPannable)view).ShowScrollbars) { return(false); } return(view.ContentBox.Height < estimateContentHeight(dialog.EntryCount)); } return(false); }
private bool[,] RenderDropDownMenuVertical(IViewBoxModel view, UiElement uiContent) {//TODO: Element muss eine Mindestgröße haben //call pre hooks object cM = uiContent.text as object; callAllPreHooks(ref view, ref cM); bool[,] boxMatrix; if (uiContent.isDisabled) { boxMatrix = Helper.createBoxDeaktivatedLeft(view.ViewBox.Height, view.ViewBox.Width - 2); } else { boxMatrix = Helper.createBox(view.ViewBox.Height, view.ViewBox.Width - 2); //erstmal eine eckige Matrix // view.ViewBox.Width -2 => da open/close noch angezeigt werden muss } DropDownMenuItem dropDownMenu = (DropDownMenuItem)uiContent.uiElementSpecialContent; //Der Type mussan dieser Stelle vorher nicht geprüft werden, da das schon in der aufrufenden Methode gemacht wurde if (dropDownMenu.hasPrevious) { //Helper.RemoveBottomBoarder(ref boxMatrix); Helper.RemoveTopBoarder(ref boxMatrix); } //String to Braille/Matrix MatrixBrailleRenderer m = new MatrixBrailleRenderer(); bool[,] textMatrix = m.RenderMatrix(view.ViewBox.Width - 4, (uiContent.text as object == null ? "" : uiContent.text as object), false); Helper.copyTextMatrixInMatrix(textMatrix, ref boxMatrix, 2); if (dropDownMenu.hasNext) { SeparatorNextDropDownMenuElementDown(ref boxMatrix); } bool[,] viewMatrix = new bool[view.ViewBox.Height, view.ViewBox.Width]; // bool[,] viewMatrix = Helper.createBox(view.ViewBox.Height - 2, view.ViewBox.Width); Helper.copyMatrixInMatrix(boxMatrix, ref viewMatrix); // macht platz in der Matrix für open/close //Anpassungen je nach spezifischen DropDownMenuItem if (dropDownMenu.hasChild) { if (dropDownMenu.isOpen) { OpenDropDownMenuElementRight(ref viewMatrix); } else { CloseDropDownMenuElementRight(ref viewMatrix); } } //call post hooks callAllPostHooks(view, cM, ref viewMatrix, false); return(viewMatrix); }
public bool[,] RenderListItem(IViewBoxModel view, UiElement uiElement) { //mehrere ListItems (als Gruppe zusammengefasst) bilden eine Liste ListMenuItem listmenuItem; if (uiElement.uiElementSpecialContent == null) { return(new bool[0, 0]); } Type typeSpecialContent = uiElement.uiElementSpecialContent.GetType(); if (typeof(ListMenuItem).Equals(typeSpecialContent)) { listmenuItem = (ListMenuItem)uiElement.uiElementSpecialContent; } else { throw new InvalidCastException("Can't cast uiElementSpecialContent to ListMenuItem! {0}"); } bool[,] matrix = new bool[view.ViewBox.Height, view.ViewBox.Width]; bool[,] text; MatrixBrailleRenderer m = new MatrixBrailleRenderer(); if (listmenuItem.hasNext) { bool[,] seperatorLine = Helper.createInterruptedLine(view.ViewBox.Width); Helper.copyMatrixInMatrix(seperatorLine, ref matrix, 0, view.ViewBox.Height - 1); } if (listmenuItem.isMultipleSelection) { bool [,] box; if (listmenuItem.isSelected) { box = Helper.createSelectedBox(4, 4); } else { box = Helper.createBox(4, 4); } Helper.copyMatrixInMatrix(box, ref matrix, 1, 1); text = m.RenderMatrix(view.ViewBox.Width - 4, (uiElement.text as object == null ? "" : uiElement.text as object), false); Helper.copyMatrixInMatrix(text, ref matrix, 6, 1); } else { text = m.RenderMatrix(view.ViewBox.Width, (uiElement.text as object == null ? "" : uiElement.text as object), false); Helper.copyMatrixInMatrix(text, ref matrix, 0, 1); } return(matrix); }
/// <summary> /// Determine if the content or some important variables of the view have changed or not. /// </summary> /// <param name="view">The view the content is presented in.</param> /// <param name="content">The content to render.</param> /// <returns><c>true</c> if some important variables has been changed since the last rendering; otherwise, <c>false</c>.</returns> protected virtual bool DidContentOrViewHaveChanged(IViewBoxModel view, object content) { string viewString = viewToString(view); if (!viewString.Equals(lastView))// !ViewBoxModelEquals(lastView, view)) { contentOrViewHasChanged(viewString, content); } else if (!lastContent.Equals(content)) { ContentOrViewHasChanged(view, content); } return(ContentChanged); }
/// <summary> /// Draw a blinking frame around the current selected shape. /// </summary> /// <param name="view"></param> /// <param name="content"></param> /// <param name="result"></param> /// <param name="additionalParams"></param> virtual protected void doBlinkingBoundingBox(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { //draw frame as bool pins if (_doRenderBoundingBox && CurrentPoint.X < 0 && CurrentPoint.Y < 0 && !(CurrentBoundingBox.Width * CurrentBoundingBox.Height < 1)) { result = paintBoundingBoxMarker(view, result); } else { result = paintPolygonPointMarker(view, result); } }
/*Checks if changes have occured and which parts of the inputbox need to be rendered again*/ private bool changeOccured(IViewBoxModel view) { if (view != null && editFieldEntry != null && editFieldEntry.InputBox != null) { if (lastView != null && lastCursorPosition != null && lastTitle != null && lastIsMinimized != null) { if (lastView.ContentBox.Width != view.ContentBox.Width) { cursorHasChanged = true; borderOrEdgeHaveChanged = true; titleHasChanged = true; viewHasChanged = true; } else { if (editFieldEntry.InputBox.IsMinimized != lastIsMinimized || editFieldEntry.Title.Length != lastTitle.Length) { borderOrEdgeHaveChanged = true; cursorHasChanged = true; titleHasChanged = true; } if (!editFieldEntry.Title.Equals(lastTitle)) { titleHasChanged = true; cursorHasChanged = true; } if (editFieldEntry.GetCursorPosition() != lastCursorPosition) { cursorHasChanged = true; if (editFieldEntry.InputBox.BoxHeightType != null && (editFieldEntry.InputBox.BoxHeightType == BoxHeightTypes.SingleLine || editFieldEntry.InputBox.MinimizeType == MinimizeTypes.AlwaysMinimize)) { titleHasChanged = true; } } } } else { lastTitle = editFieldEntry.Title; lastView = view; lastIsMinimized = editFieldEntry.InputBox.IsMinimized; viewHasChanged = true; titleHasChanged = true; borderOrEdgeHaveChanged = true; cursorHasChanged = true; } } return(viewHasChanged || titleHasChanged || borderOrEdgeHaveChanged || cursorHasChanged); }
/// <summary> /// Renders the image. /// </summary> /// <param name="img">The image.</param> /// <param name="view">The view.</param> /// <param name="offset">The offset for translation.</param> /// <param name="invert">if set to <c>true</c> the result will be inverted.</param> /// <param name="zoom">The zoom factor.</param> /// <param name="autoThreshold">if set to <c>true</c> [automatic threshold] is applied.</param> /// <param name="callHooks">if set to <c>true</c> per- and post renderer hooks are called.</param> /// <returns> /// a bool matrix /// </returns> public bool[,] RenderImage(Bitmap img, IViewBoxModel view, IPannable offset, bool invert, double zoom, bool autoThreshold, bool callHooks = true) { var vr = view.ContentBox; Bitmap img2 = img.Clone() as Bitmap; if (img2 != null) { return(RenderImage(img2, view, offset, invert, zoom, GraphicUtils.GetAverageGrayscale(vr.Width, vr.Height, new Bitmap(img2, new Size((int)Math.Round(img2.Width * zoom), (int)Math.Round(img2.Height * zoom)))) , callHooks )); } return(null); }
/// <summary> /// Renders the dialog entries and add the results into the global list of /// rendered entries for a combination afterwards. /// </summary> /// <param name="view">The view.</param> /// <param name="activeDialog">The active dialog to render.</param> /// <param name="renderedEntries">The rendered entries for touch interaction where the /// rendering results where added to.</param> /// <param name="horizontalOffset">The horizontal offset (spacing/indentation) /// from the left for some kind of indentation.</param> /// <returns> /// <c>true</c> if the entries were rendered successfully. /// </returns> protected virtual bool renderDialogEntries(IViewBoxModel view, Dialog activeDialog, ref List <RenderedDialogEntry> renderedEntries, int horizontalOffset = 0) { // var entries2render = activeDialog.GetEntryList().ToList<IDialogComponent>(); // get only top-level entries List <IDialogComponent> entries2render = activeDialog.GetEntryList().FindAll( (entry) => { return(entry != null && !entry.IsInGroup()); }).ToList <IDialogComponent>(); using (DialogEntryRenderer der = new DialogEntryRenderer()) { renderEntries(view, entries2render, ref renderedEntries, horizontalOffset, der); } return(true); }
/// <summary> /// Renders a content object into an boolean matrix; /// while <c>true</c> values indicating raised pins and <c>false</c> values indicating lowerd pins /// </summary> /// <param name="view">The frame to render in. This gives acces to the space to render and other paramenters. Normaly this is a <see cref="BrailleIOViewRange"/>.</param> /// <param name="content">The content to render.</param> /// <returns> /// A two dimensional boolean M x N matrix (bool[M,N]) where M is the count of rows (this is height) /// and N is the count of columns (which is the width). /// Positions in the Matrix are of type [i,j] /// while i is the index of the row (is the y position) /// and j is the index of the column (is the x position). /// In the matrix <c>true</c> values indicating raised pins and <c>false</c> values indicating lowerd pins /// </returns> public bool[,] RenderMatrix(IViewBoxModel view, object content) { callAllPreHooks(ref view, ref content); int width = view.ContentBox.Width; bool scrolleBars = false; var matrix = RenderMatrix(width, content, scrolleBars); view.ContentHeight = matrix.GetLength(0); view.ContentWidth = matrix.GetLength(1); callAllPostHooks(view, content, ref matrix); return(matrix); }
void IBailleIORendererHook.PostRenderHook(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { _lastView = view as BrailleIOViewRange; if (Active && CanBeActivated() ) { List<TextElemet> visibleTexts = getVisibleTextElements(view); foreach (var visibleText in visibleTexts) { renderTextFieldInMatrix(ref result, visibleText, ((BrailleIOViewRange)view).GetXOffset(), ((BrailleIOViewRange)view).GetYOffset(), ((BrailleIOViewRange)view).GetZoom()); } visibleTexts = null; } }
private List<TextElemet> getVisibleTextElements(IViewBoxModel view) { List<TextElemet> texts = getAllTextElementsOfDoc(); List<TextElemet> visibleTexts = new List<TextElemet>(); foreach (var text in texts) { if (IsElementsBoundingBoxVisibleInView(view as BrailleIOViewRange, text.ScreenPosition)) { visibleTexts.Add(text); } } return visibleTexts; }
public bool[,] RenderMatrix(IViewBoxModel view, object otherContent) { UiElement uiElement; Type typeOtherContent = otherContent.GetType(); if (typeof(UiElement).Equals(typeOtherContent)) { uiElement = (UiElement)otherContent; } else { throw new InvalidCastException("Can't cast otherContent to UiElement! {0}"); } return(RenderListItem(view, uiElement)); }
void IBailleIORendererHook.PostRenderHook(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { _lastView = view as BrailleIOViewRange; if (Active && CanBeActivated() ) { List <TextElemet> visibleTexts = getVisibleTextElements(view); foreach (var visibleText in visibleTexts) { renderTextFieldInMatrix(ref result, visibleText, ((BrailleIOViewRange)view).GetXOffset(), ((BrailleIOViewRange)view).GetYOffset(), ((BrailleIOViewRange)view).GetZoom()); } visibleTexts = null; } }
public void PreRenderHook(ref IViewBoxModel view, ref object content, params object[] additionalParams) { if (boolBlink && content != null && content is String) { string contentStr = (string)content; int caretPos = getCaretOff(contentStr) + BKI.Caret; string character = caretPos < contentStr.Length ? contentStr.Substring(caretPos, 1) : " "; var dotPattern = ScriptFunctionProxy.Instance.BrailleKeyboard.GetDotsForChar(character); if (dotPattern == null) { dotPattern = ""; } if (!dotPattern.Contains("8")) { if (!dotPattern.Contains("7")) { dotPattern += "7"; } //append 8 at the end of the string dotPattern += "8"; } else { if (!dotPattern.Contains("7")) { dotPattern.Replace("8", "78"); } } string nc = ScriptFunctionProxy.Instance.BrailleKeyboard.GetCharFromDots(dotPattern); // char with underline dots 7 & 8 if (caretPos >= contentStr.Length) { contentStr += nc; } else { contentStr = contentStr.Substring(0, caretPos) + nc + contentStr.Substring(caretPos + 1); } content = contentStr; } }
void IBailleIORendererHook.PreRenderHook(ref IViewBoxModel view, ref object content, params object[] additionalParams) { }
public void PostRenderHook(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { return; }
void IBailleIORendererHook.PostRenderHook(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { if (Active && Wnd != null) { if (Wnd.Disposed) { Wnd = null; //TODO: maybe set this as not active return; } if (!ask) // refresh regularly { if ((DateTime.Now - last) > refresh) ask = true; } // check if the bound have to be updated or not if (ask || pos.Width < 1 || pos.Height < 1) { var activePage = Wnd.GetActivePage(); if (activePage != null) { System.Drawing.Rectangle pageBoundsInPx = OoDrawUtils.convertToPixel( new System.Drawing.Rectangle( -activePage.PagesObserver.ViewOffset.X + activePage.BorderLeft, -activePage.PagesObserver.ViewOffset.Y + activePage.BorderTop, activePage.Width - activePage.BorderLeft - activePage.BorderRight, activePage.Height - activePage.BorderTop - activePage.BorderBottom), activePage.PagesObserver.ZoomValue, OoDrawPagesObserver.PixelPerMeterY, OoDrawPagesObserver.PixelPerMeterY); var spos = new System.Drawing.Rectangle(pageBoundsInPx.X, pageBoundsInPx.Y, pageBoundsInPx.Width, pageBoundsInPx.Height); if (spos.Width > 0 && spos.Height > 0) { pos = spos; } ask = false; last = DateTime.Now; } } // make the document bounds relative to the chosen zoom level double zoom = view is BrailleIO.Interface.IZoomable ? zoom = ((BrailleIO.Interface.IZoomable)view).GetZoom() : 1; if (((BrailleIOViewRange)view).Name.Equals(WindowManager.VR_CENTER_NAME) && ((BrailleIOViewRange)view).Parent.Name.Equals(WindowManager.BS_MINIMAP_NAME)) { if (WindowManager.Instance != null) { zoom = WindowManager.Instance.MinimapScalingFactor; // handling for minimap mode } } Rectangle zPos = new Rectangle( (int)(pos.X * zoom), (int)(pos.Y * zoom), (int)(pos.Width * zoom), (int)(pos.Height * zoom) ); // add the panning offsets if (view is IPannable) { zPos.X += ((IPannable)view).GetXOffset(); zPos.Y += ((IPannable)view).GetYOffset(); } //TODO: decide in inner frame or outer frame int y1 = zPos.Y - 1; int y2 = zPos.Y + zPos.Height; int x1 = 0; int width = result.GetLength(1); int height = result.GetLength(0); //horizontal lines for (int x = 0; x < zPos.Width; x += 2) { x1 = zPos.X + x; if (x1 >= 0 && x1 < width) { if (y1 >= 0 && y1 < height) { result[y1, x1] = true; } if (y2 >= 0 && y2 < height) { result[y2, x1] = true; } } } x1 = zPos.X - 1; int x2 = zPos.X + zPos.Width; //vertical lines for (int y = 0; y < zPos.Height; y += 2) { y1 = zPos.Y + y; if (y1 >= 0 && y1 < height) { if (x1 >= 0 && x1 < width) { result[y1, x1] = true; } if (x2 >= 0 && x2 < width) { result[y1, x2] = true; } } } } }
private bool[,] paintBoundingBoxMarker(IViewBoxModel view, bool[,] result) { if (view is IZoomable && view is IPannable) { double zoom = ((BrailleIO.Interface.IZoomable)view).GetZoom(); int xOffset = ((IPannable)view).GetXOffset(); int yOffset = ((IPannable)view).GetYOffset(); //if (WindowManager.Instance != null && WindowManager.Instance.ScreenObserver != null && WindowManager.Instance.ScreenObserver.ScreenPos is System.Drawing.Rectangle) //{ Rectangle pageBounds = getPageBounds(); if (pageBounds.Width > 0 && pageBounds.Height > 0) { // coords of the shapes bounding box, relative to the whole captured image Rectangle relbBox = new Rectangle(CurrentBoundingBox.X - pageBounds.X, CurrentBoundingBox.Y - pageBounds.Y, CurrentBoundingBox.Width, CurrentBoundingBox.Height); // converted to braille output coords, as shown in the original view (with zoom factor and panning position applied) Rectangle out_bBox = new Rectangle( (int)Math.Round((relbBox.X * zoom) + xOffset - 1), // x (int)Math.Round((relbBox.Y * zoom) + yOffset - 1), // y (int)Math.Round((relbBox.Width * zoom) + 2), // w (int)Math.Round((relbBox.Height * zoom) + 2)); // h // check for minimal height and width if (out_bBox.Width < MIN_FRAME_SIZE) { int oldWidth = out_bBox.Width; out_bBox.Width = MIN_FRAME_SIZE; int change = out_bBox.Width - oldWidth; out_bBox.X -= ((change) / 2); } if (out_bBox.Height < MIN_FRAME_SIZE) { int oldHeight = out_bBox.Height; out_bBox.Height = MIN_FRAME_SIZE; int change = out_bBox.Height - oldHeight; out_bBox.Y -= ((change) / 2); } if (out_bBox.Width > 0 && out_bBox.Height > 0) { int result_x_max = result.GetLength(1) - 1; int result_y_max = result.GetLength(0) - 1; // rectangle coords within matrix: int x1 = Math.Max(0, out_bBox.X); // from bBox x (or 0) int x2 = Math.Min(out_bBox.X + out_bBox.Width, result_x_max); // to bBox x + w (or x rightmost of matrix) int y1 = Math.Max(0, out_bBox.Y); // from bBox y (or 0) int y2 = Math.Min(out_bBox.Y + out_bBox.Height, result_y_max); // to bBox y + h (or y bottom of matrix) // TODO capture on blink one frame, one blink out frame of matrix withing bounding box to let the content blink after capturing without having to modify dom any more // TODO: check if shape is in visible view port --> if shape is not visible, do not blink if (y2 >= y1 && x2 >= x1) { /* draw outer (inflated box) and inner (deflated box) lowered pins around the raised pins bounding box itself to improve contrast * ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ * ○ ● ● ● ● ● ● ● ● ● ● ● ● ● ● ○ * ○ ● ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ● ○ * ○ ● ○ ○ ● ○ * ○ ● ○ ○ ● ○ * ○ ● ○ ○ ● ○ * ○ ● ○ ○ ● ○ * ○ ● ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ● ○ * ○ ● ● ● ● ● ● ● ● ● ● ● ● ● ● ○ * ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ */ bool[,] target = result; // draw horizontal lines Parallel.For(x1, x2, (x) => { if (x >= 0 && x <= result_x_max) { if (y1 >= 0 && y1 <= result_y_max) { // top border if (y1 > 0) target[y1 - 1, x] = false; // outer (lowered pins) if (y1 < result_y_max && x > x1 && x < x2) target[y1 + 1, x] = false; // inner (lowered pins) target[y1, x] = (!_dashed || (x - x1) % 3 != 2) ? true : false; // raised pins, except every 3rd in dashed mode } if (y2 >= 0 && y2 <= result_y_max) { // bottom border if (y2 > 0 && x > x1 && x < x2) target[y2 - 1, x] = false; // inner (lowered pins) if (y2 < result_y_max) target[y2 + 1, x] = false; // outer (lowered pins) target[y2, x] = (!_dashed || (x - x1) % 3 != 2) ? true : false; // raised pins, except every 3rd in dashed mode } } } ); // draw vertical lines Parallel.For(y1, y2 + 1, (y) => { if (y >= 0 && y <= result_y_max) { if (x1 >= 0 && x1 <= result_x_max) { // left border if (x1 > 0) target[y, x1 - 1] = false; // outer (lowered pins) if (x1 < result_x_max && y > y1 && y < y2) target[y, x1 + 1] = false; // inner (lowered pins) target[y, x1] = (!_dashed || (y - y1) % 3 != 2) ? true : false; // raised pins, except every 3rd in dashed mode } if (x2 >= 0 && x2 <= result_x_max) { // right border if (x2 > 0 && y > y1 && y < y2) target[y, x2 - 1] = false; // inner (lowered pins) if (x2 < result_x_max) target[y, x2 + 1] = false; // outer (lowered pins) target[y, x2] = (!_dashed || (y - y1) % 3 != 2) ? true : false; // raised pins, except every 3rd in dashed mode } } } ); result = target; } } } //} } return result; }
private bool[,] paintPolygonPointMarker(IViewBoxModel view, bool[,] result) { // point; if (result != null //&& CurrentBoundingBox.X >= 0 && CurrentBoundingBox.Y >= 0 && CurrentPoint.X > 0 && CurrentPoint.Y > 0 ) { int result_x_max = result.GetLength(1); int result_y_max = result.GetLength(0); if (result_x_max * result_y_max > 0) { if (view is IZoomable && view is IPannable) { //Rectangle pageBounds = getPageBounds(); double zoom = ((BrailleIO.Interface.IZoomable)view).GetZoom(); int xOffset = ((IPannable)view).GetXOffset(); int yOffset = ((IPannable)view).GetYOffset(); // coords of the shapes bounding box, relative to the whole captured image // Rectangle relbBox = new Rectangle(CurrentBoundingBox.X - pageBounds.X, CurrentBoundingBox.Y - pageBounds.Y, CurrentBoundingBox.Width, CurrentBoundingBox.Height); Point relPoint = new Point(CurrentPoint.X //- pageBounds.X , CurrentPoint.Y //- pageBounds.Y ); // converted to braille output coords, as shown in the original view (with zoom factor and panning position applied) Point out_bBox = new Point( (int)Math.Round((relPoint.X * zoom) + xOffset - 1), // x (int)Math.Round((relPoint.Y * zoom) + yOffset - 1)); // y int x = out_bBox.X; int y = out_bBox.Y; /* * DoRenderBoundingBox * true | false * ○ | * ○ ● ○ | ○ * ○ ● + ● ○ | ○ + ○ * ○ ● ○ | ○ * ○ | */ // cross setSaveDot(x, y, ref result, DoRenderBoundingBox, result_x_max, result_y_max); setSaveDot(x - 1, y, ref result, DoRenderBoundingBox, result_x_max, result_y_max); setSaveDot(x + 1, y, ref result, DoRenderBoundingBox, result_x_max, result_y_max); setSaveDot(x, y - 1, ref result, DoRenderBoundingBox, result_x_max, result_y_max); setSaveDot(x, y + 1, ref result, DoRenderBoundingBox, result_x_max, result_y_max); if (DoRenderBoundingBox) { // cross spacing setSaveDot(x - 2, y, ref result, false, result_x_max, result_y_max); setSaveDot(x + 2, y, ref result, false, result_x_max, result_y_max); setSaveDot(x - 1, y - 1, ref result, false, result_x_max, result_y_max); setSaveDot(x - 1, y + 1, ref result, false, result_x_max, result_y_max); setSaveDot(x, y - 2, ref result, false, result_x_max, result_y_max); setSaveDot(x, y + 2, ref result, false, result_x_max, result_y_max); setSaveDot(x + 1, y - 1, ref result, false, result_x_max, result_y_max); setSaveDot(x + 1, y + 1, ref result, false, result_x_max, result_y_max); } } } } return result; }
/// <summary> /// Draw a blinking frame around the current selected shape. /// </summary> /// <param name="view"></param> /// <param name="content"></param> /// <param name="result"></param> /// <param name="additionalParams"></param> private void doBlinkingBoundingBox(IViewBoxModel view, object content, ref bool[,] result, params object[] additionalParams) { //draw frame as bool pins if (DoRenderBoundingBox && CurrentPoint.X < 0 && CurrentPoint.Y < 0 && !(CurrentBoundingBox.Width * CurrentBoundingBox.Height < 1)) { result = paintBoundingBoxMarker(view, result); } else { result = paintPolygonPointMarker(view, result); } }
public void PreRenderHook(ref IViewBoxModel view, ref object content, params object[] additionalParams) { }