private void wrapArrayOrObjectItems(WrapInfo wi, List<WrapItem> wrapItems, WrapItem info, bool wrapFirstItem, bool wrapItemsAlignStart, bool isArray)
{
wrapItems.Clear();
//we're taking over wrapping, so now we need to figure out where all the items are going to
//go
// wrappingFirstParm=mWrapFirstObjectItem;
//put in entry for first item to make things easier for alignment code and if the
//first item needs to be wrapped.
WrapItem firstItem=new WrapItem(null, info.getDepth(), info.getFirstParmPos(), info.getBreakType(), true, info.getIndent());
firstItem.setNextItemPos(info.getFirstParmPos());
wrapItems.Add(firstItem);
int alignmentOffset=updateEarlyWrapPoint(firstItem, isArray);
int itemIndent=info.getIndent();
if ((!wrapFirstItem || isFirstItemOnLine(firstItem.getStartPos())) && info.getFirstParmPos()>0)
{
itemIndent=getColumnForPosition(firstItem.getStartPos());
wrapFirstItem=false;
}
// itemIndent-=alignmentOffset; //to adjust for the open brace/bracket and spaces
// if (!wrapFirstItem)
// itemIndent=getColumnForPosition(firstItem.getStartPos());
findWrapItemsAndAdjustChildIndent(wi, info, wrapItems);
//find the first text pos for each item
foreach (WrapItem item in wrapItems)
{
if (item.getNextItemPos()<0)
{
//update item pos by finding the next non-whitespace char after the comma pos
int location=item.getStartPos()+1;
for (;location<mOutputBuffer.Length;location++)
{
if (!AntlrUtilities.isASWhitespace(mOutputBuffer[location]))
break;
}
item.setNextItemPos(location);
}
}
// if (mWrapObjectItemsPerLine>0) //predetermined how many to do per line (usually one)
// {
// //remove items that aren't used, and mark them 'used' so that they won't break again
//
// int[] maxItemWidths=new int[mWrapObjectItemsPerLine];
// findMaxItemWidths(wrapItems, maxItemWidths);
// setUsedItems(wrapItems, itemIndent, itemsPerLine);
//
// //determine (and add) extra spaces before removing items from list
// if (mWrapObjectItemsAlignStart)
// {
// addInternalSpaces(wi, wrapItems, maxItemWidths);
// }
//
// //remove items that won't receive breaks
// removeUsedItems(wrapItems);
// }
// else
{
if (wrapItemsAlignStart)
{
if (wrapFirstItem && !isFirstItemOnLine(firstItem.getStartPos()))
{
}
else
{
firstItem.setBreakUsed(true);
}
//start with max items, then work down as I find a line that's tool long
//because of the aligned columns.
int itemsPerLine=wrapItems.Count;
//decrement itemsPerLine as we try to find a fit
int[] maxItemWidths=new int[itemsPerLine];
while (itemsPerLine>1)
{
//find the max widths of items based on the given items per line
maxItemWidths=new int[itemsPerLine];
findMaxItemWidths(wrapItems, maxItemWidths);
//now, check the max widths and see if this number of items will work for all lines
int column=itemIndent;
for (int i=0;i<itemsPerLine;i++)
{
column+=maxItemWidths[i];
}
if (column<=mMaxLineLength)
break;
itemsPerLine--;
}
//mark the items as 'used' if we're not going to have to break them further
setUsedItems(wrapItems, itemIndent, itemsPerLine, wrapFirstItem, wrapFirstItem ? alignmentOffset : 0);
//I've picked a correct number of items per line--now, increment the positions where necessary.
addInternalSpaces(wi, wrapItems, maxItemWidths);
//remove items that won't receive breaks
removeUsedItems(wrapItems);
}
else //just wrapping items to line length, no alignment
{
//determine each wrap item and remove the others
int originalIndent=info.getIndent();
int currentIndent=itemIndent;
int currentItemStartPos=firstItem.getStartPos();
if (wrapFirstItem && firstItem.getAlternateFirstItemWrapPoint()>=0)
currentItemStartPos=firstItem.getAlternateFirstItemWrapPoint();
int itemsSinceLastWrap=0;
for (int i=0;i<wrapItems.Count;i++)
{
WrapItem item=wrapItems[i];
int nextStartPos = mOutputBuffer.ToString().IndexOf('\n', item.getStartPos());
if (nextStartPos<0)
nextStartPos=mOutputBuffer.Length;
if (i+1<wrapItems.Count)
{
WrapItem nextItem = wrapItems[i+1];
nextStartPos=nextItem.getStartPos();
}
int testLength=nextStartPos-currentItemStartPos+currentIndent+1;
// String testString=mOutputBuffer.Substring(currentItemStartPos, nextStartPos);
// int testLength=currentIndent+getColumnLength(0, testString, 0, testString.Length);
if (testLength>mMaxLineLength && itemsSinceLastWrap>0 && !isFirstItemOnLine(item.getStartPos()))
{
currentItemStartPos=item.getNextItemPos();
if (!info.isIndentToFirstParm()) //switch indent if we are not indenting to first item
{
currentIndent=originalIndent+alignmentOffset;
}
itemsSinceLastWrap=1;
}
else
{
if (i>0 || !wrapFirstItem || isFirstItemOnLine(item.getStartPos()))
item.setBreakUsed(true); //don't need to break here
if (item.isBreakUsed() || i==0) //1st item is special because it doesn't matter if it's wrapped or not, it's still an item on the line
itemsSinceLastWrap++;
else
itemsSinceLastWrap=1; //to account for case where already on a line by itself
}
}
for (int i=1;i<wrapItems.Count;i++) //start at 1 to skip the first item
{
WrapItem item = wrapItems[i];
item.setIndent(originalIndent+alignmentOffset);
}
//remove items that won't receive breaks
removeUsedItems(wrapItems);
}
}
}
