static ME_DisplayItem *ME_MaximizeSplit(ME_WrapContext *wc, ME_DisplayItem *p, int i) { ME_DisplayItem *pp, *piter = p; int j; if (!i) return NULL; j = ME_ReverseFindNonWhitespaceV(p->member.run.strText, i); if (j>0) { pp = ME_SplitRun(wc, piter, j); wc->pt.x += piter->member.run.nWidth; return pp; } else { pp = piter; /* omit all spaces before split point */ while(piter != wc->pRowStart) { piter = ME_FindItemBack(piter, diRun); if (piter->member.run.nFlags & MERF_WHITESPACE) { pp = piter; continue; } if (piter->member.run.nFlags & MERF_ENDWHITE) { i = ME_ReverseFindNonWhitespaceV(piter->member.run.strText, piter->member.run.strText->nLen); pp = ME_SplitRun(wc, piter, i); wc->pt = pp->member.run.pt; return pp; } /* this run is the end of spaces, so the run edge is a good point to split */ wc->pt = pp->member.run.pt; wc->bOverflown = TRUE; TRACE("Split point is: %s|%s\n", debugstr_w(piter->member.run.strText->szData), debugstr_w(pp->member.run.strText->szData)); return pp; } wc->pt = piter->member.run.pt; return piter; } }
static ME_DisplayItem *ME_WrapHandleRun(ME_WrapContext *wc, ME_DisplayItem *p) { ME_DisplayItem *pp; ME_Run *run; int len; assert(p->type == diRun); if (!wc->pRowStart) wc->pRowStart = p; run = &p->member.run; run->pt.x = wc->pt.x; run->pt.y = wc->pt.y; ME_WrapSizeRun(wc, p); len = run->strText->nLen; if (wc->bOverflown) /* just skipping final whitespaces */ { /* End paragraph run can't overflow to the next line by itself. */ if (run->nFlags & MERF_ENDPARA) return p->next; if (run->nFlags & MERF_WHITESPACE) { wc->pt.x += run->nWidth; /* skip runs consisting of only whitespaces */ return p->next; } if (run->nFlags & MERF_STARTWHITE) { /* try to split the run at the first non-white char */ int black; black = ME_FindNonWhitespaceV(run->strText, 0); if (black) { wc->bOverflown = FALSE; pp = ME_SplitRun(wc, p, black); ME_CalcRunExtent(wc->context, &wc->pPara->member.para, wc->nRow ? wc->nLeftMargin : wc->nFirstMargin, &pp->member.run); ME_InsertRowStart(wc, pp); return pp; } } /* black run: the row goes from pRowStart to the previous run */ ME_InsertRowStart(wc, p); return p; } /* simply end the current row and move on to next one */ if (run->nFlags & MERF_ENDROW) { p = p->next; ME_InsertRowStart(wc, p); return p; } /* will current run fit? */ if (wc->bWordWrap && wc->pt.x + run->nWidth - wc->context->pt.x > wc->nAvailWidth) { int loc = wc->context->pt.x + wc->nAvailWidth - wc->pt.x; /* total white run ? */ if (run->nFlags & MERF_WHITESPACE) { /* let the overflow logic handle it */ wc->bOverflown = TRUE; return p; } /* TAB: we can split before */ if (run->nFlags & MERF_TAB) { wc->bOverflown = TRUE; if (wc->pRowStart == p) /* Don't split before the start of the run, or we will get an * endless loop. */ return p->next; else return p; } /* graphics: we can split before, if run's width is smaller than row's width */ if ((run->nFlags & MERF_GRAPHICS) && run->nWidth <= wc->nAvailWidth) { wc->bOverflown = TRUE; return p; } /* can we separate out the last spaces ? (to use overflow logic later) */ if (run->nFlags & MERF_ENDWHITE) { /* we aren't sure if it's *really* necessary, it's a good start however */ int black = ME_ReverseFindNonWhitespaceV(run->strText, len); ME_SplitRun(wc, p, black); /* handle both parts again */ return p; } /* determine the split point by backtracking */ pp = ME_SplitByBacktracking(wc, p, loc); if (pp == wc->pRowStart) { if (run->nFlags & MERF_STARTWHITE) { /* We had only spaces so far, so we must be on the first line of the * paragraph (or the first line after MERF_ENDROW forced the line * break within the paragraph), since no other lines of the paragraph * start with spaces. */ /* The lines will only contain spaces, and the rest of the run will * overflow onto the next line. */ wc->bOverflown = TRUE; return p; } /* Couldn't split the first run, possible because we have a large font * with a single character that caused an overflow. */ wc->pt.x += run->nWidth; return p->next; } if (p != pp) /* found a suitable split point */ { wc->bOverflown = TRUE; return pp; } /* we detected that it's best to split on start of this run */ if (wc->bOverflown) return pp; ERR("failure!\n"); /* not found anything - writing over margins is the only option left */ } if ((run->nFlags & (MERF_SPLITTABLE | MERF_STARTWHITE)) || ((run->nFlags & (MERF_GRAPHICS|MERF_TAB)) && (p != wc->pRowStart))) { wc->pLastSplittableRun = p; } wc->pt.x += run->nWidth; return p->next; }
static ME_DisplayItem *ME_SplitByBacktracking(ME_WrapContext *wc, ME_DisplayItem *p, int loc) { ME_DisplayItem *piter = p, *pp; int i, idesp, len; ME_Run *run = &p->member.run; idesp = i = ME_CharFromPoint(wc->context, loc, run); len = run->strText->nLen; assert(len>0); assert(i<len); if (i) { /* don't split words */ i = ME_ReverseFindWhitespaceV(run->strText, i); pp = ME_MaximizeSplit(wc, p, i); if (pp) return pp; } TRACE("Must backtrack to split at: %s\n", debugstr_w(p->member.run.strText->szData)); if (wc->pLastSplittableRun) { if (wc->pLastSplittableRun->member.run.nFlags & (MERF_GRAPHICS|MERF_TAB)) { wc->pt = wc->pLastSplittableRun->member.run.pt; return wc->pLastSplittableRun; } else if (wc->pLastSplittableRun->member.run.nFlags & MERF_SPLITTABLE) { /* the following two lines are just to check if we forgot to call UpdateRunFlags earlier, they serve no other purpose */ ME_UpdateRunFlags(wc->context->editor, run); assert((wc->pLastSplittableRun->member.run.nFlags & MERF_SPLITTABLE)); piter = wc->pLastSplittableRun; run = &piter->member.run; len = run->strText->nLen; /* don't split words */ i = ME_ReverseFindWhitespaceV(run->strText, len); if (i == len) i = ME_ReverseFindNonWhitespaceV(run->strText, len); if (i) { ME_DisplayItem *piter2 = ME_SplitRun(wc, piter, i); wc->pt = piter2->member.run.pt; return piter2; } /* splittable = must have whitespaces */ assert(0 == "Splittable, but no whitespaces"); } else { /* restart from the first run beginning with spaces */ wc->pt = wc->pLastSplittableRun->member.run.pt; return wc->pLastSplittableRun; } } TRACE("Backtracking failed, trying desperate: %s\n", debugstr_w(p->member.run.strText->szData)); /* OK, no better idea, so assume we MAY split words if we can split at all*/ if (idesp) return ME_SplitRun(wc, piter, idesp); else if (wc->pRowStart && piter != wc->pRowStart) { /* don't need to break current run, because it's possible to split before this run */ wc->bOverflown = TRUE; return piter; } else { /* split point inside first character - no choice but split after that char */ if (len != 1) { /* the run is more than 1 char, so we may split */ return ME_SplitRun(wc, piter, 1); } /* the run is one char, can't split it */ return piter; } }
static ME_DisplayItem *ME_WrapHandleRun(ME_WrapContext *wc, ME_DisplayItem *p) { ME_DisplayItem *pp; ME_Run *run; int len; assert(p->type == diRun); if (!wc->pRowStart) wc->pRowStart = p; run = &p->member.run; run->pt.x = wc->pt.x; run->pt.y = wc->pt.y; ME_WrapSizeRun(wc, p); len = ME_StrVLen(run->strText); if (wc->bOverflown) /* just skipping final whitespaces */ { if (run->nFlags & (MERF_WHITESPACE|MERF_TAB)) { p->member.run.nFlags |= MERF_SKIPPED; /* wc->pt.x += run->nWidth; */ /* skip runs consisting of only whitespaces */ return p->next; } if (run->nFlags & MERF_STARTWHITE) { /* try to split the run at the first non-white char */ int black; black = ME_FindNonWhitespaceV(run->strText, 0); if (black) { wc->bOverflown = FALSE; pp = ME_SplitRun(wc, p, black); p->member.run.nFlags |= MERF_SKIPPED; ME_InsertRowStart(wc, pp); return pp; } } /* black run: the row goes from pRowStart to the previous run */ ME_InsertRowStart(wc, p); return p; } /* simply end the current row and move on to next one */ if (run->nFlags & MERF_ENDROW) { p = p->next; ME_InsertRowStart(wc, p); return p; } /* we're not at the end of the row */ if (run->nFlags & MERF_TAB) { /* force recomputation of tabs' size as it depends on position */ ME_CalcRunExtent(wc->context, &ME_GetParagraph(p)->member.para, wc->nRow ? wc->nLeftMargin : wc->nFirstMargin, run); } /* will current run fit? */ if (wc->pt.x + run->nWidth > wc->nAvailWidth) { int loc = wc->nAvailWidth - wc->pt.x; /* total white run ? */ if (run->nFlags & MERF_WHITESPACE) { /* let the overflow logic handle it */ wc->bOverflown = TRUE; return p; } /* TAB: we can split before */ if (run->nFlags & MERF_TAB) { wc->bOverflown = TRUE; return p; } /* graphics: we can split before, if run's width is smaller than row's width */ if ((run->nFlags & MERF_GRAPHICS) && run->nWidth <= wc->nAvailWidth) { wc->bOverflown = TRUE; return p; } /* can we separate out the last spaces ? (to use overflow logic later) */ if (run->nFlags & MERF_ENDWHITE) { /* we aren't sure if it's *really* necessary, it's a good start however */ int black = ME_ReverseFindNonWhitespaceV(run->strText, len); ME_SplitRun(wc, p, black); /* handle both parts again */ return p; } /* determine the split point by backtracking */ pp = ME_SplitByBacktracking(wc, p, loc); if (pp == wc->pRowStart) { /* we had only spaces so far, entire content can be omitted */ wc->pt.x = 0; return p->next; } if (p != pp) /* found a suitable split point */ { wc->bOverflown = TRUE; return pp; } /* we detected that it's best to split on start of this run */ if (wc->bOverflown) return pp; ERR("failure!\n"); /* not found anything - writing over margins is the only option left */ } if ((run->nFlags & (MERF_SPLITTABLE | MERF_STARTWHITE)) || ((run->nFlags & (MERF_GRAPHICS|MERF_TAB)) && (p != wc->pRowStart))) { wc->pLastSplittableRun = p; wc->ptLastSplittableRun = wc->pt; } wc->pt.x += run->nWidth; return p->next; }