Ignore:
Timestamp:
2004-08-18T11:01:56+12:00 (20 years ago)
Author:
mdewsnip
Message:

Fixed code indenting.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/gli/src/org/greenstone/gatherer/metadata/MetadataAuditTableModel.java

    r7827 r7978  
    1414
    1515public class MetadataAuditTableModel
    16    extends AbstractTableModel
     16    extends AbstractTableModel
    1717{
    18    /** The FileNodes this model is built for */
    19    private FileNode[] file_nodes = null;
    20    private ArrayList metadata_values = null;
     18    /** The FileNodes this model is built for */
     19    private FileNode[] file_nodes = null;
     20    private ArrayList metadata_values = null;
    2121
    2222
    23    /** Returns the number of columns in this table. */
    24    public int getColumnCount()
    25    {
    26       return 1;  // !!! TO DO
    27    }
     23    /** Returns the number of columns in this table. */
     24    public int getColumnCount()
     25    {
     26    return 1;  // !!! TO DO
     27    }
    2828
    2929
    30 //    /** Retrieves the name of the specified column. */
    31 //    public String getColumnName(int col)
    32 //    {
    33 //       return COLUMN_NAMES[col];
    34 //    }
     30    //    /** Retrieves the name of the specified column. */
     31    //    public String getColumnName(int col)
     32    //    {
     33    //       return COLUMN_NAMES[col];
     34    //    }
    3535
    3636
    … …  
    4747
    4848   /** Returns the number of rows in this table. */
    49    public int getRowCount()
    50    {
    51       return metadata_values.size();
    52    }
     49    public int getRowCount()
     50    {
     51    return metadata_values.size();
     52    }
    5353
    5454
    55    /** Returns the cell value at a given row and column as an Object. */
    56    public Object getValueAt(int row, int col)
    57    {
    58       // Check values are reasonable
    59       if (row < 0 || row >= metadata_values.size() || col < 0 || col >= getColumnCount()) {
    60     return null;
    61       }
     55    /** Returns the cell value at a given row and column as an Object. */
     56    public Object getValueAt(int row, int col)
     57    {
     58    // Check values are reasonable
     59    if (row < 0 || row >= metadata_values.size() || col < 0 || col >= getColumnCount()) {
     60        return null;
     61    }
    6262
    63       return null;
    64    }
     63    return null;
     64    }
    6565
    6666
    67 //    public void rebuild(FileNode[] file_nodes)
    68 //    {
    69 //       metadata_value_table_entries.clear();
     67    public void rebuild(FileNode[] file_nodes)
     68    {
     69    metadata_values.clear();
    7070
    71 //       if (!Gatherer.c_man.ready()) {
    72 //   Gatherer.println("Not ready!");
    73 //   return;
    74 //       }
    75 
    76 //       this.file_nodes = file_nodes;
    77 //       if (file_nodes != null && file_nodes.length > 0) {
    78 //   // Create model builder
    79 //   MetadataValueTableModelBuilder builder = new MetadataValueTableModelBuilder();
    80 //   builder.run();
    81 //       }
    82 //    }
     71    this.file_nodes = file_nodes;
     72    }
    8373
    8474
    85 //    private class MetadataValueTableModelBuilder
    86 //    {
    87 //       public void run()
    88 //       {
    89 //   // Build a list of MetadataValueTableEntries that represent the metadata asssigned to the selected files
    90 //   boolean hid_extracted_metadata = false;
    91 //   boolean has_inherited_metadata = false;
    92 //   ArrayList metadata_elements_seen = new ArrayList();
     75    //    public void rebuild(FileNode[] file_nodes)
     76    //    {
     77    //       metadata_value_table_entries.clear();
    9378
    94 //   // Process each of the selected files in turn
    95 //   for (int i = 0; i < file_nodes.length; i++) {
    96 //      File current_file = file_nodes[i].getFile();
     79    //       if (!Gatherer.c_man.ready()) {
     80    //   Gatherer.println("Not ready!");
     81    //   return;
     82    //       }
    9783
    98 //      // Get the metadata assigned to this file
    99 //      ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedToFile(current_file);
    100 //      for (int j = 0; j < assigned_metadata.size(); j++) {
    101 //         MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(j);
    102 //         MetadataElement metadata_element = metadata_value.getMetadataElement();
    103 
    104 //         // Note if there is inherited (folder-level) metadata in the table
    105 //         has_inherited_metadata = has_inherited_metadata || metadata_value.isInheritedMetadata();
    106 
    107 //         // Insert this metadata value into the table, unless it already exists (in which case increment its count)
    108 //         insertMetadataValueIntoTable(metadata_value);
    109 
    110 //         // Remember we have seen this metadata element
    111 //         if (metadata_elements_seen.contains(metadata_element) == false) {
    112 //        metadata_elements_seen.add(metadata_element);
    113 //         }
    114 //      }
    115 
    116 //      // Get the extracted metadata for this file, if desired
    117 //      if (Gatherer.config.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) == true) {
    118 //         ArrayList extracted_metadata = DocXMLFileManager.getMetadataExtractedFromFile(current_file);
    119 //         for (int k = 0; k < extracted_metadata.size(); k++) {
    120 //        MetadataValue metadata_value = (MetadataValue) extracted_metadata.get(k);
    121 
    122 //        // Insert this metadata value into the table, unless it already exists (in which case increment its count)
    123 //        insertMetadataValueIntoTable(metadata_value);
    124 //         }
    125 //      }
    126 //   }
    127 
    128 //   // Make sure each non-extracted metadata element appears in the table (even if blank)
    129 //   ArrayList every_metadata_set_element = MetadataSetManager.getEveryMetadataSetElement();
    130 //   for (int i = 0; i < every_metadata_set_element.size(); i++) {
    131 //      MetadataElement metadata_element = (MetadataElement) every_metadata_set_element.get(i);
    132 
    133 //      // If we haven't seen this metadata element and it isn't extracted, add it now
    134 //      if (!metadata_elements_seen.contains(metadata_element) && !metadata_element.isExtractedMetadata()) {
    135 //         MetadataValueTableEntry metadata_value_table_entry = new MetadataValueTableEntry(metadata_element, new MetadataValueTreeNode(""));
    136 
    137 //         // Blank metadata is common to all selected files (otherwise it wouldn't be blank!)
    138 //         metadata_value_table_entry.setOccurrences(file_nodes.length);
    139 
    140 //         // Add it to the table
    141 //         insertMetadataValueIntoTable(metadata_value_table_entry);
    142 //      }
    143 //   }
    144 
    145 //   // If extracted metadata was hidden, display the warning
    146 //   if (hid_extracted_metadata) {
    147 //      showExtractedMetadataWarning();
    148 //   }
    149 
    150 //   // If there is inherited metadata, display the warning
    151 //   if (has_inherited_metadata) {
    152 //      showInheritedMetadataWarning();
    153 //   }
    154 //       }
     84    //       this.file_nodes = file_nodes;
     85    //       if (file_nodes != null && file_nodes.length > 0) {
     86    //   // Create model builder
     87    //   MetadataValueTableModelBuilder builder = new MetadataValueTableModelBuilder();
     88    //   builder.run();
     89    //       }
     90    //    }
    15591
    15692
    157 //       /** Alphabetically inserts the new metadata value into the table */
    158 //       private void insertMetadataValueIntoTable(MetadataValue metadata_value)
    159 //       {
    160 //   for (int i = 0; i < metadata_value_table_entries.size(); i++) {
    161 //      MetadataValueTableEntry current_metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(i);
    162 //      int c = current_metadata_value_table_entry.compareTo(metadata_value);
     93    //    private class MetadataValueTableModelBuilder
     94    //    {
     95    //       public void run()
     96    //       {
     97    //   // Build a list of MetadataValueTableEntries that represent the metadata asssigned to the selected files
     98    //   boolean hid_extracted_metadata = false;
     99    //   boolean has_inherited_metadata = false;
     100    //   ArrayList metadata_elements_seen = new ArrayList();
    163101
    164 //      // Insert value before existing entry
    165 //      if (c > 0) {
    166 //         metadata_value_table_entries.add(i, new MetadataValueTableEntry(metadata_value));
    167 //         fireTableRowsInserted(i, i);
    168 //         return;
    169 //      }
     102    //   // Process each of the selected files in turn
     103    //   for (int i = 0; i < file_nodes.length; i++) {
     104    //      File current_file = file_nodes[i].getFile();
    170105
    171 //      // Entry already exists (increment existing count)
    172 //      if (c == 0) {
    173 //         current_metadata_value_table_entry.anotherOccurrence();
    174 //         return;
    175 //      }
    176 //   }
     106    //      // Get the metadata assigned to this file
     107    //      ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedToFile(current_file);
     108    //      for (int j = 0; j < assigned_metadata.size(); j++) {
     109    //         MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(j);
     110    //         MetadataElement metadata_element = metadata_value.getMetadataElement();
    177111
    178 //   // Must go at the end of the table
    179 //   metadata_value_table_entries.add(new MetadataValueTableEntry(metadata_value));
    180 //   fireTableRowsInserted(metadata_value_table_entries.size() - 1, metadata_value_table_entries.size() - 1);
    181 //       }
     112    //         // Note if there is inherited (folder-level) metadata in the table
     113    //         has_inherited_metadata = has_inherited_metadata || metadata_value.isInheritedMetadata();
     114
     115    //         // Insert this metadata value into the table, unless it already exists (in which case increment its count)
     116    //         insertMetadataValueIntoTable(metadata_value);
     117
     118    //         // Remember we have seen this metadata element
     119    //         if (metadata_elements_seen.contains(metadata_element) == false) {
     120    //        metadata_elements_seen.add(metadata_element);
     121    //         }
     122    //      }
     123
     124    //      // Get the extracted metadata for this file, if desired
     125    //      if (Gatherer.config.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) == true) {
     126    //         ArrayList extracted_metadata = DocXMLFileManager.getMetadataExtractedFromFile(current_file);
     127    //         for (int k = 0; k < extracted_metadata.size(); k++) {
     128    //        MetadataValue metadata_value = (MetadataValue) extracted_metadata.get(k);
     129
     130    //        // Insert this metadata value into the table, unless it already exists (in which case increment its count)
     131    //        insertMetadataValueIntoTable(metadata_value);
     132    //         }
     133    //      }
     134    //   }
     135
     136    //   // Make sure each non-extracted metadata element appears in the table (even if blank)
     137    //   ArrayList every_metadata_set_element = MetadataSetManager.getEveryMetadataSetElement();
     138    //   for (int i = 0; i < every_metadata_set_element.size(); i++) {
     139    //      MetadataElement metadata_element = (MetadataElement) every_metadata_set_element.get(i);
     140
     141    //      // If we haven't seen this metadata element and it isn't extracted, add it now
     142    //      if (!metadata_elements_seen.contains(metadata_element) && !metadata_element.isExtractedMetadata()) {
     143    //         MetadataValueTableEntry metadata_value_table_entry = new MetadataValueTableEntry(metadata_element, new MetadataValueTreeNode(""));
     144
     145    //         // Blank metadata is common to all selected files (otherwise it wouldn't be blank!)
     146    //         metadata_value_table_entry.setOccurrences(file_nodes.length);
     147
     148    //         // Add it to the table
     149    //         insertMetadataValueIntoTable(metadata_value_table_entry);
     150    //      }
     151    //   }
     152
     153    //   // If extracted metadata was hidden, display the warning
     154    //   if (hid_extracted_metadata) {
     155    //      showExtractedMetadataWarning();
     156    //   }
     157
     158    //   // If there is inherited metadata, display the warning
     159    //   if (has_inherited_metadata) {
     160    //      showInheritedMetadataWarning();
     161    //   }
     162    //       }
     163
     164
     165    //       /** Alphabetically inserts the new metadata value into the table */
     166    //       private void insertMetadataValueIntoTable(MetadataValue metadata_value)
     167    //       {
     168    //   for (int i = 0; i < metadata_value_table_entries.size(); i++) {
     169    //      MetadataValueTableEntry current_metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(i);
     170    //      int c = current_metadata_value_table_entry.compareTo(metadata_value);
     171
     172    //      // Insert value before existing entry
     173    //      if (c > 0) {
     174    //         metadata_value_table_entries.add(i, new MetadataValueTableEntry(metadata_value));
     175    //         fireTableRowsInserted(i, i);
     176    //         return;
     177    //      }
     178
     179    //      // Entry already exists (increment existing count)
     180    //      if (c == 0) {
     181    //         current_metadata_value_table_entry.anotherOccurrence();
     182    //         return;
     183    //      }
     184    //   }
     185
     186    //   // Must go at the end of the table
     187    //   metadata_value_table_entries.add(new MetadataValueTableEntry(metadata_value));
     188    //   fireTableRowsInserted(metadata_value_table_entries.size() - 1, metadata_value_table_entries.size() - 1);
     189    //       }
    182190}
Note: See TracChangeset for help on using the changeset viewer.