function disp(t,bold,indent,fullChar,nestedLevel)

%DISP Display a table.

%   DISP(T) prints the table T, including variable names and row names (if

%   present), without printing the table name.  In all other ways it's the

%   same as leaving the semicolon off an expression.

%

%   For numeric or categorical variables that are 2-dimensional and have 3 or

%   fewer columns, DISP prints the actual data using either short g, long g,

%   or bank format, depending on the current command line setting.  Otherwise,

%   DISP prints the size and type of each table element.

%

%   For character variables that are 2-dimensional and 10 or fewer characters

%   wide, DISP prints quoted strings.  Otherwise, DISP prints the size and

%   type of each table element.

%

%   For cell variables that are 2-dimensional and have 3 or fewer columns,

%   DISP prints the contents of each cell (or its size and type if too large).

%   Otherwise, DISP prints the size of each tabble element.

%

%   For other types of variables, DISP prints the size and type of each

%   table element.

%

%   See also TABLE, DISPLAY, FORMAT.

%   Copyright 2012-2019 The MathWorks, Inc.

if nargin < 2, bold = true; end 

if nargin < 3, indent = 4; end 

if nargin < 4, fullChar = false; end 

if nargin < 5, nestedLevel = 1; end 

between = 4; 

betweenColSpaces = 2; 

maxNumVarColsToDisp = 5; 

maxCharWidthToDisp = 10; 

% Follow the cmd window's format settings as possible

isLoose = strcmp(matlab.internal.display.formatSpacing,'loose'); 

if isLoose 

    looseline = newline; 

else

    looseline = '';

end 

[dblFmt,snglFmt] = getFloatFormats(); 

bold = matlab.internal.display.isHot() && bold; 

strongBegin = '';strongEnd = ''; 

if bold 

    strongBegin = getString(message('MATLAB:table:localizedStrings:StrongBegin')); 

    strongEnd = getString(message('MATLAB:table:localizedStrings:StrongEnd')); 

end 

lostWidth = zeros(t.rowDim.length,1); 

marginChars = nSpaces(indent); 

if (t.rowDim.length > 0) && (t.varDim.length > 0) 

    if t.rowDim.hasLabels 

        rownameChars = string(t.rowDim.textLabels()); 

        for i=1:t.rowDim.length 

            rownameChars{i} = matlab.internal.display.truncateLine(rownameChars{i}); 

        end 

        [rownameChars,rownameWidth,lostWidth] = alignTabularContents(rownameChars,lostWidth); 

        if t.dispRowLabelsHeader 

            rowDimName = boldifyLabels(string(t.metaDim.labels{1}),bold,strongBegin,strongEnd);

            rowDimNameWidth = ceil(vectorizedWrappedLength(rowDimName));

            if rownameWidth < rowDimNameWidth

                rownameChars = rownameChars + nSpaces(rowDimNameWidth-rownameWidth);

                rownameWidth = rowDimNameWidth;

            end

        end 

        rownameChars = boldifyLabels(rownameChars,bold,strongBegin,strongEnd); 

        marginChars = marginChars + rownameChars + nSpaces(between); 

    end 

    % Boldify variable names and figure out their wrapped length.

    varNames = string(t.varDim.labels); 

    % Replace LF with "knuckle" tab with "arrow", and CR with "backarrow".

    % This also truncates long lines, but is irrelevant here.

    % Replaces hyperlinks with no display text with ''.

    for iv = 1:numel(varNames) 

        varNames(iv) = matlab.internal.display.truncateLine(varNames(iv),10000); 

    end 

    varNameOrigNumChars = strlength(varNames); 

    varNameDispWidths = varNameOrigNumChars; 

    [varNames, liesAboutWidth] = boldifyLabels(varNames,bold,strongBegin,strongEnd); 

    for idx = 1:numel(varNames) 

        liesAboutWidth(idx) = liesAboutWidth(idx) || any(varNames{idx} > char(128)); 

    end 

    varNameDispWidths(liesAboutWidth) = vectorizedWrappedLength(varNames(liesAboutWidth)); 

    varNameDispWidths = ceil(varNameDispWidths); 

    varDispWidths = zeros(1,t.varDim.length); 

    ulDispWidths = zeros(1,t.varDim.length); 

    numNestedVars = zeros(1,t.varDim.length); 

    nestedVarnameStrs = strings(1,t.varDim.length); 

    haveNestedTable = false; 

    tblChars = strings(t.rowDim.length,t.varDim.length); 

    for ivar = 1:t.varDim.length 

        var = t.data{ivar}; 

        varname = varNames(ivar); 

        if ischar(var) 

            if ismatrix(var) && (fullChar || (size(var,2) <= maxCharWidthToDisp))

                % Display individual strings for a char variable that is 2D and no

                % more than 10 chars.

                varStr = string(var);

            else

                % Otherwise, display a description of the chars.

                varStr = getInfoDisplay(var);

            end

            [varStr,maxVarLen,lostWidth] = alignTabularContents(varStr,lostWidth);

        else 

            % Display the individual data if the var is 2D and no more than 5 columns.

            if ~isempty(var) && ismatrix(var) && (size(var,2) <= maxNumVarColsToDisp) 

                if isnumeric(var) && ~isenum(var) 

                    if isa(var,'double') 

                        varChars = num2str(var,dblFmt); 

                    elseif isfloat(var) % single, or fallback for any other floating point type

                        varChars = num2str(var,snglFmt);

                    elseif isa(var,'uint8') || isa(var,'uint16') || isa(var,'uint32') || isa(var,'uint64')

                        varChars = num2str(var,'%u    ');

                    elseif isinteger(var) % standard signed integers, or fallback for any other integer type

                        varChars = num2str(var,'%d    ');

                    else % fallback for anything numeric that fails isfloat or isinteger

                        varChars = num2str(var);

                    end 

                    varStr = string(varChars); 

                    maxVarLen = max(strlength(varStr)); 

                elseif islogical(var)

                    % Display the logical values using meaningful names.

                    tf = ["false" "true "];

                    s = reshape(tf(1+var),size(var));

                    varStr = s.join(nSpaces(betweenColSpaces),2);

                    maxVarLen = max(strlength(varStr));

                elseif isa(var,'categorical') || isa(var,'datetime') || isa(var,'duration') || isa(var,'calendarDuration')

                    if isa(var,'categorical')

                        checkChars = categories(var);

                        padSide = 'right';

                    else

                        checkChars = {var.Format};

                        padSide = 'left';

                    end

                    % Convert values to a string array. String is a data

                    % conversion, so missing values need to be handled

                    % specially.

                    varStr = string(var);

                    miss = var(1); miss(1) = missing; miss = char(miss);

                    varStr(ismissing(varStr)) = miss;

                    tagged = containsRegexp(checkChars,'<a\s+href\s*=|<strong>');

                    if any(any(char(checkChars) > 127)) || any(tagged(:))                        

                        % Align the var data display accounting for wide chars

                        % or markup in a category name or a date/time format.

                        [varStr, ~, ~] = alignTabularContents(varStr);

                        varStr = varStr.join(nSpaces(betweenColSpaces),2);

                        [varStr,maxVarLen,lostWidth] = alignTabularContents(varStr,lostWidth);

                    else

                        % Otherwise, no wide chars or markup, just pad to equal

                        % number of chars.

                        varStr = pad(varStr,padSide,' ');

                        varStr = varStr.join(nSpaces(betweenColSpaces),2);                        

                        maxVarLen = max(strlength(varStr));

                    end

                elseif isstring(var)

                    if isscalar(var) && ~ismissing(var) 

                        % Scalar string displays specially, which is not what we

                        % want inside a table. Truncate long text, replace LF

                        % with "knuckle", tab with "arrow", and CR with "backarrow".

                        var = matlab.internal.display.truncateLine(var{1},10000);

                        % Scalar strings display without quotes, add them to the

                        % string itself.

                        var = '"' + string(var) + '"';

                    end

                    varStr = getStrOutput(var);

                    [varStr,maxVarLen,lostWidth] = alignTabularContents(varStr,lostWidth);

                elseif iscell(var)

                    if isscalar(var) && ischar(var{1}) && ~isempty(var{1})

                        % One-row char displays specially, which is not what we

                        % want inside a table. Truncate long text, replace LF with

                        % "knuckle", tab with "arrow", and CR with "backarrow".

                        % But avoid truncateLine on empty char; it turns 1x0 into

                        % '', a 0x0.

                        var = {matlab.internal.display.truncateLine(var{1},10000)};

                    end

                    varStr = getStrOutput(var);

                    [varStr,maxVarLen,lostWidth] = alignTabularContents(varStr,lostWidth);

                elseif isenum(var)

                    % Convert enum values to strings. value names don't contain

                    % wide chars or markup, just pad to equal number of chars.

                    varStr = pad(getStrOutput(var),' ');

                    maxVarLen = max(strlength(varStr));

                elseif isa(var,'tabular') && (nestedLevel == 1)

                    haveNestedTable = true;

                    % Get the nested table's disp, bold per caller, no indent, and

                    % whatever char disp setting our caller gave us. Tell the nested

                    % table that it's one level deeper than we are.

                    varChars = evalc('disp(var,bold,0,fullChar,nestedLevel+1)');

                    assert(sum(varChars==newline) == t.rowDim.length+2+2*isLoose) % a table's disp should never have embedded newlines

                    varStr = splitlines(string(varChars));

                    % Save the first line of the nested table's display, that's

                    % its var names, then chop off the first two lines and any

                    % trailing blank lines, leaving just the data display.

                    nestedVarnameStrs(ivar) = varStr(1);

                    numNestedVars(ivar) = var.varDim.length + (var.rowDim.hasLabels && var.dispRowLabelsHeader);

                    varStr(1:2) = [];

                    varStr(varStr == "") = [];

                    % Find the maximum width of the nested table's data display.

                    % This accounts for any wide chars in the nested table's

                    % data or row names. It does not explicitly account for the

                    % width of the nested table's var names, which will become

                    % an extra header line for the outer table. But tabular/disp

                    % creates (approx) equal-length lines of text for the nested

                    % table, including its var names header line, so their width

                    % need not be accounted for separately.

                    [varStr,maxVarLen,lostWidth] = alignTabularContents(varStr,lostWidth);

                else

                    % Display a description of each table element.

                    varStr = getInfoDisplay(var);

                    maxVarLen = max(strlength(varStr));

                end 

                % Either the variable is not 2D, or it's empty, or it's too wide

                % to show. Display a description of each table element.

            else

                varStr = getInfoDisplay(var);

                maxVarLen = max(strlength(varStr));

            end 

        end 

        if maxVarLen < varNameDispWidths(ivar) 

            % If the var name is wider than the var's data display, pad the

            % latter with spaces to center the data under the varname. Need to

            % do this explicitly, because while each line has (approx) the same

            % display width, they may have different numbers of chars due to wide

            % chars and markup, and pad requires a common target width.

            varDataPad = varNameDispWidths(ivar) - maxVarLen;

            numRightSpaces = ceil(varDataPad/2);

            numLeftSpaces = varDataPad - numRightSpaces;

            varStr = nSpaces(numLeftSpaces) + varStr + nSpaces(numRightSpaces);

            maxVarLen = varNameDispWidths(ivar);

        end 

        varDispWidths(ivar) = maxVarLen; 

        ulDispWidths(ivar) = maxVarLen; 

        tblChars(:,ivar) = varStr; 

    end 

    [varChars,nestedVarChars,underlines] = getVarNamesDispLines(); 

    disp(char(varChars)); 

    if haveNestedTable, disp(char(nestedVarChars)); end 

    disp(char(underlines)); 

    tblChars = marginChars + tblChars.join('    ',2); 

    for row = 1:t.rowDim.length 

        disp(char(tblChars(row,:))); 

    end 

    fprintf(looseline); 

end 

%-----------------------------------------------------------------------

    function [varnames,nestedVarnames,underlines] = getVarNamesDispLines()

        varStrs = strings(1,t.varDim.length);

        ulStrs = strings(1,t.varDim.length);

        if haveNestedTable, nestedVarnameDispWidths = ceil(vectorizedWrappedLength(nestedVarnameStrs)); end

        for ii = 1:t.varDim.length

            varname = varNames(ii);

            % Use the wider of varDispWidth and varNamesDispWidth to

            % determine the header width and pad to the varDispWidth if

            % necessary. However, when padding, this number has to be

            % adjusted to account for the fact that the number of

            % characters in the char vector for the varname do not

            % correspond to the display width, due to:

            % * Strong tags

            % * Hyperlinks (and thus no strong tags)

            % * Wide characters

            % * Narrow characters or wide-displaying characters that don't

            % report to be wide (nothing to be done about those).

            % Pad out variable names if necessary to match the data display

            % width. Varnames have already been made bold.

            varnameNumCharsToDisp = strlength(varname) + (varDispWidths(ii) - varNameDispWidths(ii));

            varStrs(ii) = pad(varname, ... % wrap tightly with strong tags

                              varnameNumCharsToDisp,'both',' ');

            if haveNestedTable

                % Pad the nested var names out to the full data display width,

                % accounting for bold markup tags around each nested name.

                nestedVarnameStrs(ii) = pad(nestedVarnameStrs(ii), ...

                                            strlength(nestedVarnameStrs(ii)) + (varDispWidths(ii) - nestedVarnameDispWidths(ii)),'both',' ');

            end

            % Create underlines under each variable name to the full data

            % display width.

            ulStrs(ii) = nUnder(ulDispWidths(ii));

        end

        if t.dispRowLabelsHeader

            % Need to print the name of the rowDim; add it to the beginning

            % of the array            

            ulStrs = [nUnder(rownameWidth), ulStrs];        

            varStrs = [pad(rowDimName, ... % wrap tightly with strong tags

                           strlength(rowDimName) + (rownameWidth - rowDimNameWidth),'both',' '), varStrs];

            nestedVarnameStrs = [nSpaces(rownameWidth), nestedVarnameStrs];

        end

        % Join all the variable names and underlines with spaces.

        spacesBetween = string(nSpaces(between));

        if ~t.dispRowLabelsHeader && t.rowDim.hasLabels

            % table doesn't print a header (dimname) for rownames, but we

            % still have to account for the width with additional spaces.

            leadingSpaces = nSpaces(indent + rownameWidth + between);

        else

            % timetables always wind up here, and tables without rownames

            leadingSpaces = nSpaces(indent);

        end

        varnames = leadingSpaces + join(varStrs,spacesBetween);

        nestedVarnames = leadingSpaces + join(nestedVarnameStrs,spacesBetween);

        underlines = leadingSpaces + join(strongBegin + ulStrs + strongEnd, spacesBetween) + looseline;

    end

end % main function