Example usage for com.itextpdf.text Phrase Phrase

List of usage examples for com.itextpdf.text Phrase Phrase

Introduction

In this page you can find the example usage for com.itextpdf.text Phrase Phrase.

Prototype

public Phrase(final float leading, final String string) 

Source Link

Document

Constructs a Phrase with a certain leading and a certain String.

Usage

From source file:fenix.planner.pdf.PDFGenerator.java

License:Open Source License

private void createAndAddEventTable() throws DocumentException {
    PdfPTable table = new PdfPTable(new float[] { 1, 7, 1.2f });
    table.setWidthPercentage(100f);//from w w  w .  j a v  a 2 s .c om
    table.getDefaultCell().setUseAscender(true);
    table.getDefaultCell().setUseDescender(true);
    table.setSpacingBefore(20);
    table.setSpacingAfter(20);

    // Header row
    table.getDefaultCell().setBorderWidthLeft(0);
    table.getDefaultCell().setBorderWidthTop(0);
    table.getDefaultCell().setBorderWidthRight(0);
    table.getDefaultCell().setPadding(5);
    table.getDefaultCell().setHorizontalAlignment(Element.ALIGN_LEFT);
    table.addCell(new Phrase("Datum", headerFont));
    table.addCell(new Phrase("mne", headerFont));
    table.addCell(new Phrase("Ansvarig", headerFont));
    table.setHeaderRows(1);
    table.getDefaultCell().setBackgroundColor(null);

    // Events
    for (Event event : program.getSortedCopyOfEvents()) {
        if (event.getDate().getMonthOfYear() % 2 == 0) {
            table.getDefaultCell().setBackgroundColor(new BaseColor(0xdd, 0xdd, 0xdd));
        } else {
            table.getDefaultCell().setBackgroundColor(null);
        }

        if (!event.getType().getBackgroundColor().equals(Color.WHITE)) {
            table.getDefaultCell()
                    .setBackgroundColor(awtColorToBaseColor(event.getType().getBackgroundColor()));
        }

        final BaseColor textColor = awtColorToBaseColor(event.getType().getForegroundColor());

        PdfPCell dateCell = new PdfPCell(table.getDefaultCell());
        dateCell.addElement(
                new Phrase(event.getDate().toString("dd.MM", locale), changeColor(subjectFont, textColor)));
        table.addCell(dateCell);

        PdfPCell subjectCell = new PdfPCell(table.getDefaultCell());
        subjectCell.addElement(new Phrase(event.getSubject(), changeColor(subjectFont, textColor)));
        if (event.getDescription().length() > 0) {
            subjectCell.addElement(new Phrase(event.getDescription(), changeColor(descriptionFont, textColor)));
        }
        if (event.getOrganizer() == null) {
            subjectCell.setColspan(2);
        }
        table.addCell(subjectCell);

        if (event.getOrganizer() != null) {
            PdfPCell organizerCell = new PdfPCell(table.getDefaultCell());
            organizerCell.addElement(
                    new Phrase(event.getOrganizer().getInitials(), changeColor(subjectFont, textColor)));
            table.addCell(organizerCell);
        }
    }

    document.add(table);
}

From source file:fenix.planner.pdf.PDFGenerator.java

License:Open Source License

private void createAndAddOrganizerTable() throws DocumentException {
    PdfPTable table = new PdfPTable(new float[] { 1, 3, 4, 2 });
    table.setSpacingBefore(20);/*  w  ww. j  a v  a 2  s  .  com*/

    table.setWidthPercentage(100f);
    table.getDefaultCell().setUseAscender(true);
    table.getDefaultCell().setUseDescender(true);

    // Header row
    table.getDefaultCell().setBorder(0);
    table.getDefaultCell().setPadding(5);
    table.getDefaultCell().setHorizontalAlignment(Element.ALIGN_LEFT);
    table.getDefaultCell().setBackgroundColor(null);

    for (Organizer organizer : program.getSortedCopyOfOrganizers()) {
        table.addCell(new Phrase(organizer.getInitials(), organizerFont));
        table.addCell(new Phrase(organizer.getFullName(), organizerFont));
        table.addCell(new Phrase(organizer.getEmail(), organizerFont));
        table.addCell(new Phrase(organizer.getPhoneNumber(), organizerFont));
    }

    document.add(table);
}

From source file:fenix.planner.pdf.PDFGenerator.java

License:Open Source License

private void addPageNumbers(PdfReader reader, PdfCopy copy) {
    int pageCount = reader.getNumberOfPages();
    PdfImportedPage page;//from  w  w w .  j ava2  s. com
    PdfCopy.PageStamp stamp;

    for (int i = 1; i <= pageCount; ++i) {
        Rectangle rect = reader.getBoxSize(i, "art");
        page = copy.getImportedPage(reader, i);
        stamp = copy.createPageStamp(page);
        // add page numbers
        ColumnText.showTextAligned(stamp.getUnderContent(), Element.ALIGN_RIGHT,
                new Phrase(String.format("%d / %d", i, pageCount), footerFont), rect.getRight(),
                rect.getBottom() + 5, 0);
        try {
            stamp.alterContents();
            copy.addPage(page);
        } catch (BadPdfFormatException | IOException ex) {
            throw new PDFGenerationException("Error adding page number to page " + i, ex);
        }
    }
}

From source file:fll.web.playoff.ScoresheetGenerator.java

License:Open Source License

public void writeFile(final OutputStream out, final boolean orientationIsPortrait) throws DocumentException {

    // This creates our new PDF document and declares its orientation
    Document pdfDoc;//www  . jav  a2  s .  c o  m
    if (orientationIsPortrait) {
        pdfDoc = new Document(PageSize.LETTER); // portrait
    } else {
        pdfDoc = new Document(PageSize.LETTER.rotate()); // landscape
    }
    PdfWriter.getInstance(pdfDoc, out);

    // Measurements are always in points (72 per inch)
    // This sets up 1/2 inch margins side margins and 0.35in top and bottom
    // margins
    pdfDoc.setMargins(0.5f * POINTS_PER_INCH, 0.5f * POINTS_PER_INCH, 0.35f * POINTS_PER_INCH,
            0.35f * POINTS_PER_INCH);
    pdfDoc.open();

    // Header cell with challenge title to add to both scoresheets
    final Paragraph titleParagraph = new Paragraph();
    final Chunk titleChunk = new Chunk(m_pageTitle,
            FontFactory.getFont(FontFactory.HELVETICA_BOLD, 14, Font.NORMAL, BaseColor.WHITE));
    titleParagraph.setAlignment(Element.ALIGN_CENTER);
    titleParagraph.add(titleChunk);

    titleParagraph.add(Chunk.NEWLINE);
    final Chunk swVersionChunk = new Chunk("SW version: " + Version.getVersion(),
            FontFactory.getFont(FontFactory.HELVETICA, 8, Font.NORMAL, BaseColor.WHITE));
    titleParagraph.add(swVersionChunk);
    if (null != m_revision) {

        final Chunk revisionChunk = new Chunk(" Descriptor revision: " + m_revision,
                FontFactory.getFont(FontFactory.HELVETICA, 8, Font.NORMAL, BaseColor.WHITE));

        titleParagraph.add(revisionChunk);
    }

    final PdfPCell head = new PdfPCell();
    head.setColspan(2);
    head.setBorder(1);
    head.setPaddingTop(0);
    head.setPaddingBottom(3);
    head.setBackgroundColor(new BaseColor(64, 64, 64));
    head.setVerticalAlignment(Element.ALIGN_TOP);
    head.addElement(titleParagraph);

    // Cells for score field, and 2nd check initials
    final Phrase des = new Phrase("Data Entry Score _______", ARIAL_8PT_NORMAL);
    final PdfPCell desC = new PdfPCell(des);
    desC.setBorder(0);
    desC.setPaddingTop(9);
    desC.setPaddingRight(36);
    desC.setHorizontalAlignment(Element.ALIGN_RIGHT);
    final Phrase sci = new Phrase("2nd Check Initials _______", ARIAL_8PT_NORMAL);
    final PdfPCell sciC = new PdfPCell(sci);
    sciC.setBorder(0);
    sciC.setPaddingTop(9);
    sciC.setPaddingRight(36);
    sciC.setHorizontalAlignment(Element.ALIGN_RIGHT);

    // Create a table with a grid cell for each scoresheet on the page
    PdfPTable wholePage = getTableForPage(orientationIsPortrait);
    wholePage.setWidthPercentage(100);
    for (int i = 0; i < m_numSheets; i++) {
        if (i > 0 && (orientationIsPortrait || (i % 2) == 0)) {
            pdfDoc.newPage();
            wholePage = getTableForPage(orientationIsPortrait);
            wholePage.setWidthPercentage(100);
        }

        // This table is a single score sheet
        final PdfPTable scoreSheet = new PdfPTable(2);
        // scoreSheet.getDefaultCell().setBorder(Rectangle.LEFT | Rectangle.BOTTOM
        // | Rectangle.RIGHT | Rectangle.TOP); //FIXME DEBUG should be NO_BORDER
        scoreSheet.getDefaultCell().setBorder(Rectangle.NO_BORDER);
        scoreSheet.getDefaultCell().setPaddingRight(1);
        scoreSheet.getDefaultCell().setPaddingLeft(0);

        scoreSheet.addCell(head);

        final PdfPTable teamInfo = new PdfPTable(7);
        teamInfo.setWidthPercentage(100);
        teamInfo.setWidths(new float[] { 1f, 1f, 1f, 1f, 1f, 1f, .9f });

        // Time label cell
        final Paragraph timeP = new Paragraph("Time:", ARIAL_10PT_NORMAL);
        timeP.setAlignment(Element.ALIGN_RIGHT);
        final PdfPCell timeLc = new PdfPCell(scoreSheet.getDefaultCell());
        timeLc.addElement(timeP);
        teamInfo.addCell(timeLc);
        // Time value cell
        final Paragraph timeV = new Paragraph(null == m_time[i] ? SHORT_BLANK : m_time[i], COURIER_10PT_NORMAL);
        final PdfPCell timeVc = new PdfPCell(scoreSheet.getDefaultCell());
        timeVc.addElement(timeV);
        teamInfo.addCell(timeVc);

        // Table label cell
        final Paragraph tblP = new Paragraph("Table:", ARIAL_10PT_NORMAL);
        tblP.setAlignment(Element.ALIGN_RIGHT);
        final PdfPCell tblLc = new PdfPCell(scoreSheet.getDefaultCell());
        tblLc.addElement(tblP);
        teamInfo.addCell(tblLc);
        // Table value cell
        final Paragraph tblV = new Paragraph(m_table[i], COURIER_10PT_NORMAL);
        final PdfPCell tblVc = new PdfPCell(scoreSheet.getDefaultCell());
        tblVc.addElement(tblV);
        teamInfo.addCell(tblVc);

        // Round number label cell
        final Paragraph rndP = new Paragraph("Round:", ARIAL_10PT_NORMAL);
        rndP.setAlignment(Element.ALIGN_RIGHT);
        final PdfPCell rndlc = new PdfPCell(scoreSheet.getDefaultCell());
        rndlc.addElement(rndP);
        teamInfo.addCell(rndlc);
        // Round number value cell
        final Paragraph rndV = new Paragraph(m_round[i], COURIER_10PT_NORMAL);
        final PdfPCell rndVc = new PdfPCell(scoreSheet.getDefaultCell());
        // rndVc.setColspan(2);
        rndVc.addElement(rndV);
        teamInfo.addCell(rndVc);

        final PdfPCell temp1 = new PdfPCell(scoreSheet.getDefaultCell());
        // temp1.setColspan(2);
        temp1.addElement(new Paragraph("Judge ____", ARIAL_8PT_NORMAL));
        teamInfo.addCell(temp1);

        // Team number label cell
        final Paragraph nbrP = new Paragraph("Team #:", ARIAL_10PT_NORMAL);
        nbrP.setAlignment(Element.ALIGN_RIGHT);
        final PdfPCell nbrlc = new PdfPCell(scoreSheet.getDefaultCell());
        nbrlc.addElement(nbrP);
        teamInfo.addCell(nbrlc);
        // Team number value cell
        final Paragraph nbrV = new Paragraph(null == m_number[i] ? SHORT_BLANK : String.valueOf(m_number[i]),
                COURIER_10PT_NORMAL);
        final PdfPCell nbrVc = new PdfPCell(scoreSheet.getDefaultCell());
        nbrVc.addElement(nbrV);
        teamInfo.addCell(nbrVc);

        // Team division label cell
        final Paragraph divP = new Paragraph(m_divisionLabel[i], ARIAL_10PT_NORMAL);
        divP.setAlignment(Element.ALIGN_RIGHT);
        final PdfPCell divlc = new PdfPCell(scoreSheet.getDefaultCell());
        divlc.addElement(divP);
        divlc.setColspan(2);
        teamInfo.addCell(divlc);
        // Team division value cell
        final Paragraph divV = new Paragraph(m_division[i], COURIER_10PT_NORMAL);
        final PdfPCell divVc = new PdfPCell(scoreSheet.getDefaultCell());
        divVc.setColspan(2);
        divVc.addElement(divV);
        teamInfo.addCell(divVc);

        final PdfPCell temp2 = new PdfPCell(scoreSheet.getDefaultCell());
        // temp2.setColspan(2);
        temp2.addElement(new Paragraph("Team ____", ARIAL_8PT_NORMAL));
        teamInfo.addCell(temp2);

        // Team name label cell
        final Paragraph nameP = new Paragraph("Team Name:", ARIAL_10PT_NORMAL);
        nameP.setAlignment(Element.ALIGN_RIGHT);
        final PdfPCell namelc = new PdfPCell(scoreSheet.getDefaultCell());
        namelc.setColspan(2);
        namelc.addElement(nameP);
        teamInfo.addCell(namelc);
        // Team name value cell
        final Paragraph nameV = new Paragraph(m_name[i], COURIER_10PT_NORMAL);
        final PdfPCell nameVc = new PdfPCell(scoreSheet.getDefaultCell());
        nameVc.setColspan(5);
        nameVc.addElement(nameV);
        teamInfo.addCell(nameVc);

        // add team info cell to the team table
        final PdfPCell teamInfoCell = new PdfPCell(scoreSheet.getDefaultCell());
        teamInfoCell.addElement(teamInfo);
        teamInfoCell.setColspan(2);

        scoreSheet.addCell(teamInfoCell);

        if (null != m_goalsTable) {
            final PdfPCell goalCell = new PdfPCell(m_goalsTable);
            goalCell.setBorder(0);
            goalCell.setPadding(0);
            goalCell.setColspan(2);
            scoreSheet.addCell(goalCell);
        }

        scoreSheet.addCell(desC);
        scoreSheet.addCell(sciC);

        if (null != m_copyright) {
            final Phrase copyright = new Phrase("\u00A9" + m_copyright, f6i);
            final PdfPCell copyrightC = new PdfPCell(scoreSheet.getDefaultCell());
            copyrightC.addElement(copyright);
            copyrightC.setBorder(0);
            copyrightC.setHorizontalAlignment(Element.ALIGN_CENTER);
            copyrightC.setColspan(2);

            scoreSheet.addCell(copyrightC);
        }

        // the cell in the whole page table that will contain the single score
        // sheet
        final PdfPCell scoresheetCell = new PdfPCell(scoreSheet);
        scoresheetCell.setBorder(0);
        scoresheetCell.setPadding(0);

        // Interior borders between scoresheets on a page
        if (!orientationIsPortrait) {
            if (i % 2 == 0) {
                scoresheetCell.setPaddingRight(0.1f * POINTS_PER_INCH);
            } else {
                scoresheetCell.setPaddingLeft(0.1f * POINTS_PER_INCH);
            }
        }

        // Add the current scoresheet to the page
        wholePage.addCell(scoresheetCell);

        // Add the current table of scoresheets to the document
        if (orientationIsPortrait || (i % 2 != 0)) {
            pdfDoc.add(wholePage);
        }
    }

    // Add a blank cells to complete the table of the last page
    if (!orientationIsPortrait && m_numSheets % 2 != 0) {
        final PdfPCell blank = new PdfPCell();
        blank.setBorder(0);
        wholePage.addCell(blank);
        pdfDoc.add(wholePage);
    }

    pdfDoc.close();
}

From source file:fll.web.playoff.ScoresheetGenerator.java

License:Open Source License

/**
 * Stores the goal cells that are inserted into the output after the team name
 * headers and before the scoring/initials blanks at the bottom of the
 * scoresheet.//from w w w .  j  av a2 s .c  o  m
 */
private void setChallengeInfo(final ChallengeDescription description) {
    setPageTitle(description.getTitle());

    if (null != description.getRevision()) {
        setRevisionInfo(description.getRevision());
    }

    if (null != description.getCopyright()) {
        m_copyright = description.getCopyright();
    } else {
        m_copyright = null;
    }

    final PerformanceScoreCategory performanceElement = description.getPerformance();
    // use ArrayList as we will be doing indexed access in the loop
    final List<AbstractGoal> goals = new ArrayList<>(performanceElement.getGoals());

    final float[] relativeWidths = new float[3];
    relativeWidths[0] = 4;
    relativeWidths[1] = 48;
    relativeWidths[2] = 48;
    m_goalsTable = new PdfPTable(relativeWidths);

    String prevCategory = null;
    for (int goalIndex = 0; goalIndex < goals.size(); ++goalIndex) {
        final AbstractGoal goal = goals.get(goalIndex);
        if (!goal.isComputed()) {
            final String category = goal.getCategory();

            // add category cell if needed
            boolean firstRowInCategory = false;
            if (!StringUtils.equals(prevCategory, category)) {
                if (!StringUtils.isEmpty(category)) {

                    // find out how many future goals have the same category
                    int categoryRowSpan = 1;
                    for (int otherIndex = goalIndex + 1; otherIndex < goals.size(); ++otherIndex) {
                        final AbstractGoal otherGoal = goals.get(otherIndex);
                        if (!otherGoal.isComputed()) {
                            if (StringUtils.equals(category, otherGoal.getCategory())) {
                                ++categoryRowSpan;
                            } else {
                                break;
                            }
                        }
                    }

                    final Paragraph catPara = new Paragraph(category, ARIAL_10PT_NORMAL);
                    final PdfPCell categoryCell = new PdfPCell(catPara);
                    categoryCell.setBorderWidthTop(1);
                    categoryCell.setBorderWidthBottom(0);
                    categoryCell.setBorderWidthLeft(0);
                    categoryCell.setBorderWidthRight(0);
                    categoryCell.setVerticalAlignment(Element.ALIGN_CENTER);
                    categoryCell.setHorizontalAlignment(Element.ALIGN_CENTER);
                    categoryCell.setRotation(90);
                    categoryCell.setRowspan(categoryRowSpan);
                    m_goalsTable.addCell(categoryCell);
                }

                // first row in a new category, which may be empty
                firstRowInCategory = true;
            }

            // This is the text for the left hand "label" cell
            final String title = goal.getTitle();
            final Paragraph p = new Paragraph(title, ARIAL_10PT_NORMAL);
            final PdfPCell goalLabel = new PdfPCell(p);
            goalLabel.setHorizontalAlignment(Element.ALIGN_RIGHT);
            goalLabel.setVerticalAlignment(Element.ALIGN_CENTER);
            if (firstRowInCategory) {
                goalLabel.setBorderWidthTop(1);
                goalLabel.setBorderWidthBottom(0);
                goalLabel.setBorderWidthLeft(0);
                goalLabel.setBorderWidthRight(0);
            } else {
                goalLabel.setBorder(0);
            }
            goalLabel.setPaddingRight(9);
            goalLabel.setVerticalAlignment(Element.ALIGN_TOP);
            if (StringUtils.isEmpty(category)) {
                // category column and goal label column
                goalLabel.setColspan(2);
            }
            m_goalsTable.addCell(goalLabel);

            // define the value cell
            final double min = goal.getMin();
            final String minStr = FP.equals(min, Math.round(min), 1E-6) ? String.valueOf((int) min)
                    : String.valueOf(min);
            final double max = goal.getMax();
            final String maxStr = FP.equals(max, Math.round(max), 1E-6) ? String.valueOf((int) max)
                    : String.valueOf(max);

            // If element has child nodes, then we have an enumerated list
            // of choices. Otherwise it is either yes/no or a numeric field.
            final PdfPCell goalValue = new PdfPCell();
            final Chunk choices = new Chunk("", COURIER_10PT_NORMAL);
            if (goal.isEnumerated()) {
                // replace spaces with "no-break" spaces
                boolean first = true;
                final List<EnumeratedValue> values = goal.getSortedValues();
                for (final EnumeratedValue value : values) {
                    if (!first) {
                        choices.append(" /" + Utilities.NON_BREAKING_SPACE);
                    } else {
                        first = false;
                    }
                    choices.append(value.getTitle().toUpperCase().replace(' ', Utilities.NON_BREAKING_SPACE));
                }
                goalValue.addElement(choices);

            } else {
                if (goal.isYesNo()) {
                    // order of yes/no needs to match ScoreEntry.generateYesNoButtons
                    final Paragraph q = new Paragraph("NO / YES", COURIER_10PT_NORMAL);
                    goalValue.addElement(q);

                } else {
                    final String range = "(" + minStr + " - " + maxStr + ")";
                    final PdfPTable t = new PdfPTable(2);
                    t.setHorizontalAlignment(Element.ALIGN_LEFT);
                    t.setTotalWidth(1 * POINTS_PER_INCH);
                    t.setLockedWidth(true);
                    final Phrase r = new Phrase("", ARIAL_8PT_NORMAL);
                    t.addCell(new PdfPCell(r));
                    final Phrase q = new Phrase(range, ARIAL_8PT_NORMAL);
                    t.addCell(new PdfPCell(q));
                    goalValue.setPaddingTop(9);
                    goalValue.addElement(t);
                }
            }

            if (firstRowInCategory) {
                goalValue.setBorderWidthTop(1);
                goalValue.setBorderWidthBottom(0);
                goalValue.setBorderWidthLeft(0);
                goalValue.setBorderWidthRight(0);
            } else {
                goalValue.setBorder(0);
            }
            goalValue.setVerticalAlignment(Element.ALIGN_MIDDLE);

            m_goalsTable.addCell(goalValue);

            // setup for next loop
            prevCategory = category;
        } // if not computed goal

    } // foreach goal

}

From source file:fll.web.report.FinalComputedScores.java

License:Open Source License

@SuppressFBWarnings(value = {
        "SQL_PREPARED_STATEMENT_GENERATED_FROM_NONCONSTANT_STRING" }, justification = "Category name determines table name")
private void writeScores(final Connection connection, final ScoreCategory[] subjectiveCategories,
        final double[] weights, final float[] relativeWidths, final String awardGroup,
        final WinnerType winnerCriteria, final Tournament tournament, final PdfPTable divTable,
        final Set<Integer> bestTeams) throws SQLException {

    final Map<ScoreCategory, Map<String, Map<Integer, Integer>>> teamSubjectiveRanks = gatherRankedSubjectiveTeams(
            connection, subjectiveCategories, winnerCriteria, tournament, awardGroup);

    final Map<Integer, Integer> teamPerformanceRanks = gatherRankedPerformanceTeams(connection, winnerCriteria,
            tournament, awardGroup);/*from   ww  w .  j a  va2s.  c  om*/

    ResultSet rawScoreRS = null;
    PreparedStatement teamPrep = null;
    ResultSet teamsRS = null;
    PreparedStatement scorePrep = null;
    try {
        final StringBuilder query = new StringBuilder();
        query.append(
                "SELECT Teams.Organization,Teams.TeamName,Teams.TeamNumber,FinalScores.OverallScore,FinalScores.performance,current_tournament_teams.judging_station");
        for (int cat = 0; cat < subjectiveCategories.length; cat++) {
            if (weights[cat] > 0.0) {
                final String catName = subjectiveCategories[cat].getName();
                query.append(",FinalScores." + catName);
            }
        }
        query.append(" FROM Teams,FinalScores,current_tournament_teams");
        query.append(" WHERE FinalScores.TeamNumber = Teams.TeamNumber");
        query.append(" AND FinalScores.Tournament = ?");
        query.append(" AND current_tournament_teams.event_division = ?");
        query.append(" AND current_tournament_teams.TeamNumber = Teams.TeamNumber");
        query.append(
                " ORDER BY FinalScores.OverallScore " + winnerCriteria.getSortString() + ", Teams.TeamNumber");
        teamPrep = connection.prepareStatement(query.toString());
        teamPrep.setInt(1, tournament.getTournamentID());
        teamPrep.setString(2, awardGroup);
        teamsRS = teamPrep.executeQuery();

        scorePrep = connection
                .prepareStatement("SELECT score FROM performance_seeding_max" + " WHERE TeamNumber = ?");

        while (teamsRS.next()) {
            final int teamNumber = teamsRS.getInt(3);
            final String organization = teamsRS.getString(1);
            final String teamName = teamsRS.getString(2);
            final String judgingGroup = teamsRS.getString(6);

            final double totalScore;
            final double ts = teamsRS.getDouble(4);
            if (teamsRS.wasNull()) {
                totalScore = Double.NaN;
            } else {
                totalScore = ts;
            }

            // ///////////////////////////////////////////////////////////////////
            // Build a table of data for this team
            // ///////////////////////////////////////////////////////////////////
            final PdfPTable curteam = new PdfPTable(relativeWidths);
            curteam.getDefaultCell().setBorder(0);

            // The first row of the team table...
            // First column is organization name
            final PdfPCell teamCol = new PdfPCell(new Phrase(organization, ARIAL_8PT_NORMAL));
            teamCol.setBorder(0);
            teamCol.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_LEFT);
            curteam.addCell(teamCol);
            curteam.getDefaultCell().setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_RIGHT);

            final PdfPCell judgeGroupCell = new PdfPCell(new Phrase(judgingGroup, ARIAL_8PT_NORMAL));
            judgeGroupCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
            judgeGroupCell.setBorder(0);
            curteam.addCell(judgeGroupCell);

            // Second column is "Raw:"
            final PdfPCell rawLabel = new PdfPCell(new Phrase("Raw:", ARIAL_8PT_NORMAL));
            rawLabel.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_RIGHT);
            rawLabel.setBorder(0);
            curteam.addCell(rawLabel);

            insertRawScoreColumns(connection, tournament, winnerCriteria.getSortString(), subjectiveCategories,
                    weights, teamNumber, curteam);

            // Column for the highest performance score of the seeding rounds
            scorePrep.setInt(1, teamNumber);
            rawScoreRS = scorePrep.executeQuery();
            final double rawScore;
            if (rawScoreRS.next()) {
                final double v = rawScoreRS.getDouble(1);
                if (rawScoreRS.wasNull()) {
                    rawScore = Double.NaN;
                } else {
                    rawScore = v;
                }
            } else {
                rawScore = Double.NaN;
            }
            PdfPCell pCell = new PdfPCell((Double.isNaN(rawScore) ? new Phrase("No Score", ARIAL_8PT_NORMAL_RED)
                    : new Phrase(Utilities.NUMBER_FORMAT_INSTANCE.format(rawScore), ARIAL_8PT_NORMAL)));
            pCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
            pCell.setBorder(0);
            curteam.addCell(pCell);
            rawScoreRS.close();

            // The "Overall score" column is not filled in for raw scores
            curteam.addCell("");

            // The second row of the team table...
            // First column contains the team # and name
            final PdfPCell teamNameCol = new PdfPCell(
                    new Phrase(Integer.toString(teamNumber) + " " + teamName, ARIAL_8PT_NORMAL));
            teamNameCol.setBorder(0);
            teamNameCol.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_LEFT);
            curteam.addCell(teamNameCol);

            // Second column contains "Scaled:"
            final PdfPCell scaledCell = new PdfPCell(new Phrase("Scaled:", ARIAL_8PT_NORMAL));
            scaledCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_RIGHT);
            scaledCell.setBorder(0);
            scaledCell.setColspan(2);
            curteam.addCell(scaledCell);

            // Next, one column containing the scaled score for each subjective
            // category with weight > 0
            for (int cat = 0; cat < subjectiveCategories.length; cat++) {
                final Map<String, Map<Integer, Integer>> catRanks = teamSubjectiveRanks
                        .get(subjectiveCategories[cat]);

                final double catWeight = weights[cat];
                if (catWeight > 0.0) {
                    final double scaledScore;
                    final double v = teamsRS.getDouble(6 + cat + 1);
                    if (teamsRS.wasNull()) {
                        scaledScore = Double.NaN;
                    } else {
                        scaledScore = v;
                    }

                    final Map<Integer, Integer> judgingRanks = catRanks.get(judgingGroup);

                    Font scoreFont;
                    final String rankText;
                    if (judgingRanks.containsKey(teamNumber)) {
                        final int rank = judgingRanks.get(teamNumber);
                        rankText = String.format("%1$s(%2$d)", Utilities.NON_BREAKING_SPACE, rank);
                        if (1 == rank) {
                            scoreFont = ARIAL_8PT_BOLD;
                        } else {
                            scoreFont = ARIAL_8PT_NORMAL;
                        }
                    } else {
                        rankText = String.format("%1$s%1$s%1$s%1$s%1$s", Utilities.NON_BREAKING_SPACE);
                        scoreFont = ARIAL_8PT_NORMAL;
                    }

                    final String scoreText;
                    if (Double.isNaN(scaledScore)) {
                        scoreText = "No Score" + rankText;
                        scoreFont = ARIAL_8PT_NORMAL_RED;
                    } else {
                        scoreText = Utilities.NUMBER_FORMAT_INSTANCE.format(scaledScore) + rankText;
                    }

                    final PdfPCell subjCell = new PdfPCell(new Phrase(scoreText, scoreFont));
                    subjCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
                    subjCell.setBorder(0);
                    curteam.addCell(subjCell);
                }
            } // foreach category

            // 2nd to last column has the scaled performance score
            {
                Font scoreFont;
                final String rankText;
                if (teamPerformanceRanks.containsKey(teamNumber)) {
                    final int rank = teamPerformanceRanks.get(teamNumber);
                    rankText = String.format("%1$s(%2$d)", Utilities.NON_BREAKING_SPACE, rank);
                    if (1 == rank) {
                        scoreFont = ARIAL_8PT_BOLD;
                    } else {
                        scoreFont = ARIAL_8PT_NORMAL;
                    }
                } else {
                    rankText = String.format("%1$s%1$s%1$s%1$s%1$s", Utilities.NON_BREAKING_SPACE);
                    scoreFont = ARIAL_8PT_NORMAL;
                }

                final double scaledScore;
                final double v = teamsRS.getDouble(5);
                if (teamsRS.wasNull()) {
                    scaledScore = Double.NaN;
                } else {
                    scaledScore = v;
                }

                final String scaledScoreStr;
                if (Double.isNaN(scaledScore)) {
                    scoreFont = ARIAL_8PT_NORMAL_RED;
                    scaledScoreStr = "No Score" + rankText;
                } else {
                    scaledScoreStr = Utilities.NUMBER_FORMAT_INSTANCE.format(scaledScore) + rankText;
                }

                pCell = new PdfPCell(new Phrase(scaledScoreStr, scoreFont));
                pCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
                pCell.setBorder(0);
                curteam.addCell(pCell);
            } // performance score

            // Last column contains the overall scaled score
            final String overallScoreSuffix;
            if (bestTeams.contains(teamNumber)) {
                overallScoreSuffix = String.format("%1$s*", Utilities.NON_BREAKING_SPACE);
            } else {
                overallScoreSuffix = String.format("%1$s%1$s", Utilities.NON_BREAKING_SPACE);
            }

            pCell = new PdfPCell((Double.isNaN(totalScore)
                    ? new Phrase("No Score" + overallScoreSuffix, ARIAL_8PT_NORMAL_RED)
                    : new Phrase(Utilities.NUMBER_FORMAT_INSTANCE.format(totalScore) + overallScoreSuffix,
                            ARIAL_8PT_NORMAL)));
            pCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
            pCell.setBorder(0);
            curteam.addCell(pCell);

            // This is an empty row in the team table that is added to put a
            // horizontal rule under the team's score in the display
            final PdfPCell blankCell = new PdfPCell();
            blankCell.setBorder(0);
            blankCell.setBorderWidthBottom(0.5f);
            blankCell.setBorderColorBottom(BaseColor.GRAY);
            blankCell.setColspan(relativeWidths.length);
            curteam.addCell(blankCell);

            // Create a new cell and add it to the division table - this cell will
            // contain the entire team table we just built above
            final PdfPCell curteamCell = new PdfPCell(curteam);
            curteamCell.setBorder(0);
            curteamCell.setColspan(relativeWidths.length);
            divTable.addCell(curteamCell);
        }

        teamsRS.close();

    } finally {
        SQLFunctions.close(teamsRS);
        SQLFunctions.close(teamPrep);
        SQLFunctions.close(rawScoreRS);
        SQLFunctions.close(scorePrep);
    }

}

From source file:fll.web.report.FinalComputedScores.java

License:Open Source License

/**
 * @throws ParseException/*  w  w w .j  a  v a 2 s.c  o m*/
 */
private void writeColumnHeaders(final TournamentSchedule schedule, final double[] weights,
        final ScoreCategory[] subjectiveCategories, final float[] relativeWidths,
        final ChallengeDescription challengeDescription, final PdfPTable divTable) throws ParseException {

    // /////////////////////////////////////////////////////////////////////
    // Write the table column headers
    // /////////////////////////////////////////////////////////////////////
    // team information
    final PdfPCell organizationCell = new PdfPCell(new Phrase("Organization", ARIAL_8PT_BOLD));
    organizationCell.setBorder(0);
    organizationCell.setVerticalAlignment(com.itextpdf.text.Element.ALIGN_MIDDLE);
    divTable.addCell(organizationCell);

    // judging group
    if (null != schedule) {
        final Paragraph judgingGroup = new Paragraph("Judging", ARIAL_8PT_BOLD);
        judgingGroup.add(Chunk.NEWLINE);
        judgingGroup.add(new Chunk("Group"));
        final PdfPCell osCell = new PdfPCell(judgingGroup);
        osCell.setBorder(0);
        osCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
        osCell.setVerticalAlignment(com.itextpdf.text.Element.ALIGN_MIDDLE);
        divTable.addCell(osCell);
    }

    divTable.addCell(""); // weight/raw&scaled

    for (int cat = 0; cat < subjectiveCategories.length; cat++) {
        if (weights[cat] > 0.0) {
            final String catTitle = subjectiveCategories[cat].getTitle();

            final Paragraph catPar = new Paragraph(catTitle, ARIAL_8PT_BOLD);
            final PdfPCell catCell = new PdfPCell(catPar);
            catCell.setBorder(0);
            catCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
            catCell.setVerticalAlignment(com.itextpdf.text.Element.ALIGN_MIDDLE);
            divTable.addCell(catCell);
        }
    }

    final Paragraph perfPar = new Paragraph("Performance", ARIAL_8PT_BOLD);
    final PdfPCell perfCell = new PdfPCell(perfPar);
    perfCell.setBorder(0);
    perfCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
    perfCell.setVerticalAlignment(com.itextpdf.text.Element.ALIGN_MIDDLE);
    divTable.addCell(perfCell);

    final Paragraph overallScore = new Paragraph("Overall", ARIAL_8PT_BOLD);
    overallScore.add(Chunk.NEWLINE);
    overallScore.add(new Chunk("Score"));
    final PdfPCell osCell = new PdfPCell(overallScore);
    osCell.setBorder(0);
    osCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
    osCell.setVerticalAlignment(com.itextpdf.text.Element.ALIGN_MIDDLE);
    divTable.addCell(osCell);

    // /////////////////////////////////////////////////////////////////////
    // Write a table row with the relative weights of the subjective scores
    // /////////////////////////////////////////////////////////////////////

    final PdfPCell teamCell = new PdfPCell(new Phrase("Team # / Team Name", ARIAL_8PT_BOLD));
    teamCell.setBorder(0);
    teamCell.setVerticalAlignment(com.itextpdf.text.Element.ALIGN_MIDDLE);
    divTable.addCell(teamCell);

    final Paragraph wPar = new Paragraph("Weight:", ARIAL_8PT_NORMAL);
    final PdfPCell wCell = new PdfPCell(wPar);
    if (null != schedule) {
        wCell.setColspan(2);
    }
    wCell.setBorder(0);
    wCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_RIGHT);
    divTable.addCell(wCell);

    final PdfPCell[] wCells = new PdfPCell[subjectiveCategories.length];
    final Paragraph[] wPars = new Paragraph[subjectiveCategories.length];
    for (int cat = 0; cat < subjectiveCategories.length; cat++) {
        if (weights[cat] > 0.0) {
            wPars[cat] = new Paragraph(Double.toString(weights[cat]), ARIAL_8PT_NORMAL);
            wCells[cat] = new PdfPCell(wPars[cat]);
            wCells[cat].setBorder(0);
            wCells[cat].setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
            divTable.addCell(wCells[cat]);
        }
    }

    final PerformanceScoreCategory performanceElement = challengeDescription.getPerformance();
    final double perfWeight = performanceElement.getWeight();
    final Paragraph perfWeightPar = new Paragraph(Double.toString(perfWeight), ARIAL_8PT_NORMAL);
    final PdfPCell perfWeightCell = new PdfPCell(perfWeightPar);
    perfWeightCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
    perfWeightCell.setBorder(0);
    divTable.addCell(perfWeightCell);

    divTable.addCell("");

    PdfPCell blankCell = new PdfPCell();
    blankCell.setBorder(0);
    blankCell.setBorderWidthBottom(1.0f);
    blankCell.setColspan(relativeWidths.length);
    divTable.addCell(blankCell);

    // Cause the first 4 rows to be repeated on
    // each page - 1 row for box header, 2 rows text headers and 1 for
    // the horizontal line.
    divTable.setHeaderRows(4);
}

From source file:fll.web.report.FinalComputedScores.java

License:Open Source License

@SuppressFBWarnings(value = {
        "SQL_PREPARED_STATEMENT_GENERATED_FROM_NONCONSTANT_STRING" }, justification = "Winner type is used to determine sort order")
private void insertRawScoreColumns(final Connection connection, final Tournament tournament,
        final String ascDesc, final ScoreCategory[] subjectiveCategories, final double[] weights,
        final int teamNumber, final PdfPTable curteam) throws SQLException {
    ResultSet rs = null;/*  w ww  .  ja v  a 2  s . c o  m*/
    PreparedStatement prep = null;
    try {
        // Next, one column containing the raw score for each subjective
        // category with weight > 0
        for (int catIndex = 0; catIndex < subjectiveCategories.length; catIndex++) {
            final ScoreCategory catElement = subjectiveCategories[catIndex];
            final double catWeight = weights[catIndex];
            if (catWeight > 0.0) {
                final String catName = catElement.getName();
                prep = connection.prepareStatement("SELECT ComputedTotal" + " FROM " + catName
                        + " WHERE TeamNumber = ? AND Tournament = ? ORDER BY ComputedTotal " + ascDesc);
                prep.setInt(1, teamNumber);
                prep.setInt(2, tournament.getTournamentID());
                rs = prep.executeQuery();
                boolean scoreSeen = false;
                final StringBuilder rawScoreText = new StringBuilder();
                while (rs.next()) {
                    final double v = rs.getDouble(1);
                    if (!rs.wasNull()) {
                        if (scoreSeen) {
                            rawScoreText.append(", ");
                        } else {
                            scoreSeen = true;
                        }
                        rawScoreText.append(Utilities.NUMBER_FORMAT_INSTANCE.format(v));
                    }
                }
                final PdfPCell subjCell = new PdfPCell(
                        (!scoreSeen ? new Phrase("No Score", ARIAL_8PT_NORMAL_RED)
                                : new Phrase(rawScoreText.toString(), ARIAL_8PT_NORMAL)));
                subjCell.setHorizontalAlignment(com.itextpdf.text.Element.ALIGN_CENTER);
                subjCell.setBorder(0);
                curteam.addCell(subjCell);
                rs.close();
            }
        }
    } finally {
        SQLFunctions.close(rs);
        SQLFunctions.close(prep);
    }
}

From source file:fll.web.report.finalist.AbstractFinalistSchedule.java

License:Open Source License

/**
 * Create a page for the specified category.
 * //from  ww w .j  a va2  s .c  o  m
 * @throws DocumentException
 * @throws SQLException
 */
private void createCategoryPage(final Document document, final Connection connection, final String category,
        final String room, final FinalistSchedule schedule) throws DocumentException, SQLException {
    // header name
    final Paragraph para = new Paragraph();
    para.add(Chunk.NEWLINE);

    para.add(new Chunk(String.format("Finalist schedule for %s", category), TITLE_FONT));
    para.add(Chunk.NEWLINE);
    if (null != room && !"".equals(room)) {
        para.add(new Chunk(String.format("Room: %s", room), TITLE_FONT));
    }
    document.add(para);

    final PdfPTable schedTable = new PdfPTable(new float[] { 12.5f, 12.5f, 37.5f, 37.5f });
    schedTable.setWidthPercentage(100);
    schedTable.getDefaultCell().setBorder(0);
    schedTable.getDefaultCell().enableBorderSide(Rectangle.BOTTOM);
    schedTable.getDefaultCell().setHorizontalAlignment(Element.ALIGN_CENTER);

    schedTable.addCell(new Phrase("Time", SCHEDULE_HEADER_FONT));

    schedTable.addCell(new Phrase("Team #", SCHEDULE_HEADER_FONT));

    schedTable.addCell(new Phrase("Team Name", SCHEDULE_HEADER_FONT));

    schedTable.addCell(new Phrase("Organization", SCHEDULE_HEADER_FONT));

    // foreach information output
    for (final FinalistDBRow row : schedule.getScheduleForCategory(category)) {
        // time, number, name, organization
        schedTable.addCell(new Phrase(String.format("%d:%02d", row.getHour(), row.getMinute()), SCHEDULE_FONT));

        final Team team = Team.getTeamFromDatabase(connection, row.getTeamNumber());
        schedTable.addCell(new Phrase(String.valueOf(team.getTeamNumber()), SCHEDULE_FONT));

        schedTable.addCell(new Phrase(team.getTeamName(), SCHEDULE_FONT));

        schedTable.addCell(new Phrase(team.getOrganization(), SCHEDULE_FONT));

    }
    document.add(schedTable);

    document.add(Chunk.NEXTPAGE);
}

From source file:fll.web.report.PerformanceScoreReport.java

License:Open Source License

private void outputTeam(final Connection connection, final Document document, final Tournament tournament,
        final ChallengeDescription challenge, final int numSeedingRounds, final TournamentTeam team)
        throws DocumentException, SQLException {
    // output first row for header
    final PdfPTable table = new PdfPTable(numSeedingRounds + 1);
    table.addCell("");
    for (int runNumber = 1; runNumber <= numSeedingRounds; ++runNumber) {

        table.addCell(new Phrase("Run " + runNumber, HEADER_FONT));
    }//from  w w w.  j av  a 2s. c om

    final PerformanceScoreCategory performance = challenge.getPerformance();

    final TeamScore[] scores = getScores(connection, tournament, team, numSeedingRounds);
    for (final AbstractGoal goal : performance.getGoals()) {
        final double bestScore = bestScoreForGoal(scores, goal);

        final StringBuilder goalTitle = new StringBuilder();
        goalTitle.append(goal.getTitle());
        if (goal.isComputed()) {
            goalTitle.append(" (computed)");
        }
        table.addCell(new Phrase(goalTitle.toString(), HEADER_FONT));

        for (final TeamScore score : scores) {
            if (!score.scoreExists() || score.isBye() || score.isNoShow()) {
                table.addCell("");
            } else {
                final double computedValue = goal.getComputedScore(score);

                final StringBuilder cellStr = new StringBuilder();
                if (!goal.isComputed()) {
                    if (goal.isEnumerated()) {
                        final String enumValue = score.getEnumRawScore(goal.getName());
                        boolean found = false;
                        for (final EnumeratedValue ev : goal.getValues()) {
                            if (ev.getValue().equals(enumValue)) {
                                cellStr.append(ev.getTitle() + " -> ");
                                found = true;
                                break;
                            }
                        }
                        if (!found) {
                            LOG.warn("Could not find enumerated title for " + enumValue);
                            cellStr.append(enumValue + " -> ");
                        }
                    } else {
                        if (goal.isYesNo()) {
                            if (FP.greaterThan(score.getRawScore(goal.getName()), 0,
                                    ChallengeParser.INITIAL_VALUE_TOLERANCE)) {
                                cellStr.append("Yes -> ");
                            } else {
                                cellStr.append("No -> ");
                            }
                        } else {
                            final double rawValue = goal.getRawScore(score);
                            cellStr.append(Utilities.NUMBER_FORMAT_INSTANCE.format(rawValue) + " -> ");
                        }
                    } // not enumerated
                } // not computed

                cellStr.append(Utilities.NUMBER_FORMAT_INSTANCE.format(computedValue));
                if (FP.equals(bestScore, computedValue, ChallengeParser.INITIAL_VALUE_TOLERANCE)) {
                    table.addCell(new Phrase(cellStr.toString(), BEST_SCORE_FONT));
                } else {
                    table.addCell(new Phrase(cellStr.toString(), SCORE_FONT));
                }
            } // exists, non-bye, non-no show

        } // foreach score
    } // foreach goal

    // totals
    table.addCell(new Phrase("Total", HEADER_FONT));
    final double bestTotalScore = bestTotalScore(performance, scores);
    for (final TeamScore score : scores) {
        if (!score.scoreExists()) {
            table.addCell("");
        } else if (score.isBye()) {
            table.addCell(new Phrase("Bye", SCORE_FONT));
        } else if (score.isNoShow()) {
            table.addCell(new Phrase("No Show", SCORE_FONT));
        } else {
            final double totalScore = performance.evaluate(score);

            if (FP.equals(bestTotalScore, totalScore, ChallengeParser.INITIAL_VALUE_TOLERANCE)) {
                table.addCell(new Phrase(Utilities.NUMBER_FORMAT_INSTANCE.format(totalScore), BEST_SCORE_FONT));
            } else {
                table.addCell(new Phrase(Utilities.NUMBER_FORMAT_INSTANCE.format(totalScore), SCORE_FONT));
            }
        }

    }

    document.add(table);

    final Paragraph definitionPara = new Paragraph();
    definitionPara.add(Chunk.NEWLINE);
    definitionPara.add(new Chunk("The team's top score for each goal and overall are in bold."));
    document.add(definitionPara);
}