Changeset 1761


Ignore:
Timestamp:
11/08/06 15:19:20 (13 years ago)
Author:
curtis
Message:

Remove EOL spaces.

Location:
trunk/loci/plugins/browser
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/plugins/browser/CacheManager.java

    r1663 r1761  
    114114  /** Holds the total size of the various dimensions of the file(s).*/ 
    115115  private int sizeZ, sizeT, sizeC; 
    116    
     116 
    117117  /** Holds the current priority of each axis.*/ 
    118118  private int curZPriority, curTPriority, curCPriority; 
    119    
     119 
    120120  /** Holds the previous priority of each axis.*/ 
    121121  private int oldZPriority, oldTPriority, oldCPriority; 
     
    132132  */ 
    133133  private boolean loop; 
    134  
    135134 
    136135  /** A list of indeces to be loaded by the caching thread.*/ 
     
    223222    this.strategy = strategy; 
    224223    this.oldStrategy = strategy; 
    225      
     224 
    226225    //set default axes' priorities 
    227226    curTPriority = 2; 
     
    321320    updateCache(); 
    322321  } 
    323    
     322 
    324323  /** 
    325324  * A method to set which axis to cache first. 
     
    330329  public void setPriority(int top, int mid, int low) { 
    331330    if (top == mid || mid == low || top == low) return; 
    332      
     331 
    333332    quit = true; 
    334      
     333 
    335334    int storeZ = curZPriority; 
    336335    int storeT = curTPriority; 
    337336    int storeC = curCPriority; 
    338      
     337 
    339338    if (top == Z_AXIS) curZPriority = 2; 
    340339    else if (top == T_AXIS) curTPriority = 2; 
     
    346345      return; 
    347346    } 
    348      
     347 
    349348    if (mid == Z_AXIS) curZPriority = 1; 
    350349    else if (mid == T_AXIS) curTPriority = 1; 
     
    356355      return; 
    357356    } 
    358      
     357 
    359358    if (low == Z_AXIS) curZPriority = 0; 
    360359    else if (low == T_AXIS) curTPriority = 0; 
     
    366365      return; 
    367366    } 
    368      
     367 
    369368    oldZPriority = curZPriority; 
    370369    oldTPriority = curTPriority; 
    371370    oldCPriority = curCPriority; 
    372      
     371 
    373372    updateCache(); 
    374373  } 
     
    653652        int firstLowBound, firstUpBound, secondLowBound, secondUpBound; 
    654653        int firstAxis, secondAxis; 
    655          
     654 
    656655        if( axis == (Z_AXIS | T_AXIS) ) { 
    657656          if (tPriority > zPriority) { 
     
    708707          } 
    709708        } 
    710          
     709 
    711710        if (strategy == FORWARD_FIRST) { 
    712711          result = getRect(firstAxis,firstLowBound,firstUpBound, 
     
    721720        //f: first | s: second | t: third 
    722721        int fLow,fUp,sLow,sUp,tLow,tUp,fAxis,sAxis,tAxis; 
    723          
     722 
    724723        if (zPriority > tPriority && zPriority > cPriority) { 
    725724          fLow = z - backZ; 
    726725          fUp = z + forwardZ; 
    727726          fAxis = Z_AXIS; 
    728            
     727 
    729728          if(tPriority > cPriority) { 
    730729            sLow = t - backT; 
     
    748747          fUp = t + forwardT; 
    749748          fAxis = T_AXIS; 
    750            
     749 
    751750          if(zPriority > cPriority) { 
    752751            sLow = z - backZ; 
     
    770769          fUp = c + forwardC; 
    771770          fAxis = C_AXIS; 
    772            
     771 
    773772          if(tPriority > zPriority) { 
    774773            sLow = t - backT; 
     
    788787          } 
    789788        } 
    790          
     789 
    791790        if (strategy == FORWARD_FIRST) { 
    792791          result = getBrick(fAxis,fLow,fUp, 
     
    829828    else if(lowSet.length != 0 && upSet.length == 0) return lowSet; 
    830829    else if(lowSet.length == 0 && upSet.length == 0) return lowSet; 
    831    
     830 
    832831    int[] result = new int[upSet.length + lowSet.length]; 
    833832    int count = 0; 
     
    11601159    return result; 
    11611160  } 
    1162    
     1161 
    11631162  /** 
    11641163  * A method to get a 2d "ring" of indeces around a given point. 
     
    11841183      } 
    11851184      catch(Exception exc) {if(DEBUG) exc.printStackTrace();} 
    1186        
    1187       int[] result = {index};      
     1185 
     1186      int[] result = {index}; 
    11881187      return result; 
    11891188    } 
     
    11911190      int[] result = {}; 
    11921191      int fUp,fLow,fSize,sUp,sLow,sSize; 
    1193        
     1192 
    11941193      if (fAxis == Z_AXIS) { 
    11951194        fSize = sizeZ; 
     
    12071206        fLow = c - r; 
    12081207      } 
    1209        
     1208 
    12101209      if (sAxis == Z_AXIS) { 
    12111210        sSize = sizeZ; 
     
    12231222        sLow = c - r; 
    12241223      } 
    1225        
     1224 
    12261225      Vector temp = new Vector(); 
    1227        
     1226 
    12281227      //The following code could be made more concise. 
    12291228      if(fUp < fSize) { 
     
    12311230          if(s >= 0 && s < sSize) { 
    12321231            int index = -1; 
    1233              
     1232 
    12341233            synchronized (read) { 
    12351234              try { 
     
    12611260              catch(Exception exc) {if(DEBUG) exc.printStackTrace();} 
    12621261            } 
    1263              
     1262 
    12641263            if (index != -1) { 
    12651264              Integer indexObj = new Integer(index); 
    1266                
     1265 
    12671266              temp.add(indexObj); 
    12681267            } 
     
    12711270        } 
    12721271      } 
    1273        
     1272 
    12741273      if(fLow >= 0) { 
    12751274        for(int s = sLow;s<=sUp;s++) { 
    12761275          if(s >= 0 && s < sSize) { 
    12771276            int index = -1; 
    1278              
     1277 
    12791278            synchronized (read) { 
    12801279              try { 
     
    13061305              catch(Exception exc) {if(DEBUG) exc.printStackTrace();} 
    13071306            } 
    1308              
     1307 
    13091308            if (index != -1) { 
    13101309              Integer indexObj = new Integer(index); 
    1311                
     1310 
    13121311              temp.add(indexObj); 
    13131312            } 
     
    13161315        } 
    13171316      } 
    1318        
     1317 
    13191318      if(sUp < sSize) { 
    13201319        for(int f = fLow + 1;f < fUp;f++) { 
    13211320          if(f >= 0 && f < fSize) { 
    13221321            int index = -1; 
    1323              
     1322 
    13241323            synchronized (read) { 
    13251324              try { 
     
    13511350              catch(Exception exc) {if(DEBUG) exc.printStackTrace();} 
    13521351            } 
    1353              
     1352 
    13541353            if (index != -1) { 
    13551354              Integer indexObj = new Integer(index); 
    1356                
     1355 
    13571356              temp.add(indexObj); 
    13581357            } 
     
    13611360        } 
    13621361      } 
    1363        
     1362 
    13641363      if(sLow >= 0) { 
    13651364        for(int f = fLow + 1;f < fUp;f++) { 
    13661365          if(f >= 0 && f < fSize) { 
    13671366            int index = -1; 
    1368              
     1367 
    13691368            synchronized (read) { 
    13701369              try { 
     
    13961395              catch(Exception exc) {if(DEBUG) exc.printStackTrace();} 
    13971396            } 
    1398              
     1397 
    13991398            if (index != -1) { 
    14001399              Integer indexObj = new Integer(index); 
    1401                
     1400 
    14021401              temp.add(indexObj); 
    14031402            } 
     
    14061405        } 
    14071406      } 
    1408    
     1407 
    14091408      Object[] tempArray = temp.toArray(); 
    14101409      result = new int[tempArray.length]; 
     
    14121411        result[i] = ((Integer)tempArray[i]).intValue(); 
    14131412      } 
    1414          
     1413 
    14151414      return result; 
    14161415    } 
    14171416  } 
    1418    
     1417 
    14191418  /** 
    14201419  * A method to get a 2d rectangular cache in FORWARD_FIRST strategy. 
     
    14481447      fMid = c; 
    14491448    } 
    1450      
     1449 
    14511450    if (sAxis == Z_AXIS) { 
    14521451      sSize = sizeZ; 
     
    14611460      sMid = c; 
    14621461    } 
    1463      
     1462 
    14641463    //clip bounds, no looping in RECT_MODE 
    14651464    if(fLow < 0) fLow = 0; 
     
    14671466    if(sLow < 0) sLow = 0; 
    14681467    if(sUp >= sSize) sUp = sSize - 1; 
    1469      
     1468 
    14701469    if(DEBUG) { 
    14711470      System.out.println("fSize: " + fSize + " | fMid:" + fMid + 
     
    14731472        " | sMid:" + sMid + " | sUp:" + sUp + " | sLow:" + sLow); 
    14741473    } 
    1475      
     1474 
    14761475    for(int sRow = sMid;sRow<=sUp;sRow++) { 
    14771476      int[] toAdd = {}; 
     
    14811480        else if (sAxis == T_AXIS) toAdd = 
    14821481          getUpSet(fLow,fUp,fAxis,z,sRow,c); 
    1483         else toAdd = getUpSet(fLow,fUp,fAxis,z,t,sRow);  
     1482        else toAdd = getUpSet(fLow,fUp,fAxis,z,t,sRow); 
    14841483      } 
    14851484      catch (Exception exc) { 
    14861485        exc.printStackTrace(); 
    14871486      } 
    1488        
     1487 
    14891488      result = append(toAdd,result); 
    14901489    } 
    1491      
     1490 
    14921491    if(sMid - 1 >= 0) { 
    14931492      for(int sRow = sMid - 1;sRow>=sLow;sRow--) { 
    14941493        int[] toAdd = {}; 
    1495    
     1494 
    14961495        try { 
    14971496          if (sAxis == Z_AXIS) toAdd = getUpSet(fLow,fUp,fAxis,sRow,t,c); 
    14981497          else if (sAxis == T_AXIS) toAdd = 
    14991498            getUpSet(fLow,fUp,fAxis,z,sRow,c); 
    1500           else toAdd = getUpSet(fLow,fUp,fAxis,z,t,sRow);  
     1499          else toAdd = getUpSet(fLow,fUp,fAxis,z,t,sRow); 
    15011500        } 
    15021501        catch (Exception exc) { 
    15031502          exc.printStackTrace(); 
    15041503        } 
    1505          
     1504 
    15061505        result = append(toAdd,result); 
    15071506      } 
    15081507    } 
    1509      
     1508 
    15101509    for(int sRow = sMid;sRow<=sUp;sRow++) { 
    15111510      int[] toAdd = {}; 
     
    15151514        else if (sAxis == T_AXIS) toAdd = 
    15161515          getLowSet(fLow,fUp,fAxis,z,sRow,c); 
    1517         else toAdd = getLowSet(fLow,fUp,fAxis,z,t,sRow);  
     1516        else toAdd = getLowSet(fLow,fUp,fAxis,z,t,sRow); 
    15181517      } 
    15191518      catch (Exception exc) { 
    15201519        exc.printStackTrace(); 
    15211520      } 
    1522        
     1521 
    15231522      result = append(toAdd,result); 
    15241523    } 
    1525      
     1524 
    15261525    if(sMid - 1 >= 0) { 
    15271526      for(int sRow = sMid - 1;sRow>=sLow;sRow--) { 
    15281527        int[] toAdd = {}; 
    1529    
     1528 
    15301529        try { 
    15311530          if (sAxis == Z_AXIS) toAdd = getLowSet(fLow,fUp,fAxis,sRow,t,c); 
    15321531          else if (sAxis == T_AXIS) toAdd = 
    15331532            getLowSet(fLow,fUp,fAxis,z,sRow,c); 
    1534           else toAdd = getLowSet(fLow,fUp,fAxis,z,t,sRow);  
     1533          else toAdd = getLowSet(fLow,fUp,fAxis,z,t,sRow); 
    15351534        } 
    15361535        catch (Exception exc) { 
    15371536          exc.printStackTrace(); 
    15381537        } 
    1539          
     1538 
    15401539        result = append(toAdd,result); 
    15411540      } 
    15421541    } 
    1543         
     1542 
    15441543    return result; 
    15451544  } 
    1546    
     1545 
    15471546  /** 
    15481547  * A method to get a 3d "brick" cache in FORWARD_FIRST strategy. 
     
    15801579      fMid = c; 
    15811580    } 
    1582      
     1581 
    15831582    if (sAxis == Z_AXIS) { 
    15841583      sSize = sizeZ; 
     
    15931592      sMid = c; 
    15941593    } 
    1595      
     1594 
    15961595    if (tAxis == Z_AXIS) { 
    15971596      tSize = sizeZ; 
     
    16061605      tMid = c; 
    16071606    } 
    1608      
     1607 
    16091608    //clip bounds, no looping in RECT_MODE 
    16101609    if(fLow < 0) fLow = 0; 
     
    16141613    if(tLow < 0) tLow = 0; 
    16151614    if(tUp >= tSize) tUp = tSize - 1; 
    1616      
     1615 
    16171616    for(int tRow = tMid;tRow<=tUp;tRow++) { 
    16181617      int[] toAdd = {}; 
    1619       if (tAxis == Z_AXIS)  
     1618      if (tAxis == Z_AXIS) 
    16201619        toAdd = getRect(fAxis,fLow,fUp,sAxis,sLow,sUp,tRow,t,c); 
    16211620      else if(tAxis == T_AXIS) 
     
    16231622      else //tAxis == C_AXIS 
    16241623        toAdd = getRect(fAxis,fLow,fUp,sAxis,sLow,sUp,z,t,tRow); 
    1625        
     1624 
    16261625      result = append(toAdd,result); 
    16271626    } 
    1628      
     1627 
    16291628    if(tMid - 1 >= 0) { 
    16301629      for(int tRow = tMid - 1;tRow>=tLow;tRow--) { 
    16311630        int[] toAdd = {}; 
    1632         if (tAxis == Z_AXIS)  
     1631        if (tAxis == Z_AXIS) 
    16331632          toAdd = getRect(fAxis,fLow,fUp,sAxis,sLow,sUp,tRow,t,c); 
    16341633        else if(tAxis == T_AXIS) 
     
    16361635        else //tAxis == C_AXIS 
    16371636          toAdd = getRect(fAxis,fLow,fUp,sAxis,sLow,sUp,z,t,tRow); 
    1638          
     1637 
    16391638        result = append(toAdd,result); 
    16401639      } 
    16411640    } 
    1642      
     1641 
    16431642    return result; 
    16441643  } 
    1645    
     1644 
    16461645  /** 
    16471646  * A method to get a 2d rectangular cache in SURROUND_FIRST strategy. 
     
    16631662    int [] result = {}; 
    16641663    int fMax, sMax, rMax; 
    1665      
     1664 
    16661665    if (fAxis == Z_AXIS) { 
    16671666      fMax = Math.max(z-fLow,fUp-z); 
     
    16731672      fMax = Math.max(z-fLow,fUp-z); 
    16741673    } 
    1675      
     1674 
    16761675    if (sAxis == Z_AXIS) { 
    16771676      sMax = Math.max(z-sLow,sUp-z); 
     
    16831682      sMax = Math.max(c-sLow,sUp-c); 
    16841683    } 
    1685      
     1684 
    16861685    rMax = Math.max(fMax,sMax); 
    1687      
     1686 
    16881687    for(int r = 0;r <= rMax;r++) { 
    16891688      int toAdd[]; 
    1690        
     1689 
    16911690      toAdd = getRing(fAxis,sAxis,z,t,c,r); 
    16921691      result = append(toAdd,result); 
    16931692    } 
    1694      
     1693 
    16951694    return result; 
    16961695  } 
     
    17281727      tMid = c; 
    17291728    } 
    1730      
     1729 
    17311730    int[] upSet = {}; 
    17321731    int[] lowSet = {}; 
    1733      
     1732 
    17341733    for(int tRow = tMid;tRow <= tUp;tRow++) { 
    17351734      int[] toAdd = {}; 
     
    17411740      else toAdd = getSpiral(fAxis,fLow,fUp, 
    17421741        sAxis,sLow,sUp,z,t,tRow); 
    1743          
    1744       upSet = append(toAdd,upSet);  
    1745     } 
    1746      
     1742 
     1743      upSet = append(toAdd,upSet); 
     1744    } 
     1745 
    17471746    if(tMid - 1 >= 0) { 
    17481747      for(int tRow = tMid - 1;tRow >= tLow;tRow--) { 
    17491748        int[] toAdd = {}; 
    1750    
     1749 
    17511750        if(tAxis == Z_AXIS) toAdd = getSpiral(fAxis,fLow,fUp, 
    17521751          sAxis,sLow,sUp,tRow,t,c); 
     
    17551754        else toAdd = getSpiral(fAxis,fLow,fUp, 
    17561755          sAxis,sLow,sUp,z,t,tRow); 
    1757            
    1758         lowSet = append(toAdd,lowSet);  
    1759       } 
    1760     } 
    1761    
     1756 
     1757        lowSet = append(toAdd,lowSet); 
     1758      } 
     1759    } 
     1760 
    17621761    result = getMix(lowSet,upSet); 
    17631762    return result; 
     
    17981797          } 
    17991798          System.out.println("}"); 
    1800            
     1799 
    18011800          System.out.print("NewIndex = {"); 
    18021801          for (int i = 0; i<newIndex.length; i++) { 
  • trunk/loci/plugins/browser/OptionsWindow.java

    r1634 r1761  
    5151  /** Parent window. */ 
    5252  private CustomWindow cw; 
    53    
     53 
    5454  /** The CacheManager for this instance of data browser.*/ 
    5555  private CacheManager manager; 
    56    
     56 
    5757  /** CheckBoxes to indicate which axes to store.*/ 
    5858  private JCheckBox zCheck,tCheck,cCheck; 
     
    6060  /** Spinners for slice storage.*/ 
    6161  private JSpinner zFSpin,zBSpin,tFSpin,tBSpin,cFSpin,cBSpin; 
    62    
     62 
    6363  /** Combo Boxes for cache mode selection.*/ 
    6464  private JComboBox modeBox,stratBox; 
    65    
     65 
    6666  /** Combo Boxes for dimensional priority selection.*/ 
    6767  private JComboBox topBox,midBox,lowBox; 
     
    6969  /** Button to reset CacheManager to default modes. */ 
    7070  private JButton resetBtn; 
    71    
     71 
    7272  /** A flag to turn off listening to gui components.*/ 
    7373  private boolean update; 
    74    
     74 
    7575  /** Storage of what priority settings used to be.*/ 
    7676  private int oldTop,oldMid,oldLow; 
     
    8282 
    8383    cw = c; 
    84      
     84 
    8585    manager = cw.db.manager; 
    86      
     86 
    8787    update = true; 
    8888 
     
    103103    JLabel tLab = new JLabel("Time:"); 
    104104    tLab.setForeground(Color.blue); 
    105      
     105 
    106106    JPanel custPanel = new JPanel(); 
    107107    custPanel.add(custLab); 
     
    171171    aniPane.add(fpsLab,cc2.xy(2,1)); 
    172172    aniPane.add(fps,cc2.xy(4,1)); 
    173      
     173 
    174174    JPanel cachePane = new JPanel(); 
    175175    TitledBorder cacheB = BorderFactory.createTitledBorder( 
    176176      etchB, "CacheManager Options"); 
    177177    cachePane.setBorder(cacheB); 
    178      
     178 
    179179    JLabel typeL = new JLabel("\u00B7" + "Cache Type" + "\u00B7"); 
    180180    JLabel axesL = new JLabel("Axes to Cache:"); 
     
    191191    JLabel midL = new JLabel("Mid Priority:"); 
    192192    JLabel lowL = new JLabel("Low Priority:"); 
    193      
     193 
    194194    JPanel typePanel = new JPanel(); 
    195195    typePanel.add(typeL); 
     
    204204    priorPanel.setBackground(Color.darkGray); 
    205205    priorL.setForeground(Color.lightGray); 
    206      
     206 
    207207    zCheck = new JCheckBox("Z"); 
    208208    tCheck = new JCheckBox("T"); 
     
    216216    tCheck.addItemListener(this); 
    217217    cCheck.addItemListener(this); 
    218      
     218 
    219219    String[] modes = {"Crosshair", "Rectangle", "Cross/Rect"}; 
    220220    modeBox = new JComboBox(modes); 
     
    233233    midBox.addActionListener(this); 
    234234    lowBox.addActionListener(this); 
    235      
     235 
    236236    SpinnerNumberModel zFMod = new SpinnerNumberModel(0,0,9999,1); 
    237237    zFSpin = new JSpinner(zFMod); 
     
    252252    cFSpin.addChangeListener(this); 
    253253    cBSpin.addChangeListener(this); 
    254      
     254 
    255255    resetBtn = new JButton("Reset CacheManager to Default"); 
    256256    resetBtn.addActionListener(this); 
    257      
     257 
    258258    FormLayout layout3 = new FormLayout( 
    259259      TAB + ",pref," + TAB + ",pref:grow," + TAB + ",pref:grow," + TAB, 
     
    262262    cachePane.setLayout(layout3); 
    263263    CellConstraints cc3 = new CellConstraints(); 
    264      
     264 
    265265    cachePane.add(typePanel,cc3.xyw(1,1,7)); 
    266266    cachePane.add(axesL,cc3.xyw(2,2,3)); 
     
    290290    cachePane.add(lowBox,cc3.xy(6,16)); 
    291291    cachePane.add(resetBtn,cc3.xyw(2,18,5,"right,center")); 
    292      
     292 
    293293    if(!cw.db.virtual) enableCache(false); 
    294294 
     
    299299    setLayout(lastLayout); 
    300300    CellConstraints ccs = new CellConstraints(); 
    301      
     301 
    302302    add(aniPane,ccs.xy(1,1)); 
    303303    add(cachePane,ccs.xy(1,2)); 
    304304    add(disPane,ccs.xy(1,3)); 
    305      
     305 
    306306    oldTop = topBox.getSelectedIndex(); 
    307307    oldMid = midBox.getSelectedIndex(); 
     
    316316    setVisible(true); 
    317317  } 
    318    
     318 
    319319  /** 
    320320  * Converts a combo box index into a CacheManager constant 
     
    332332    return -1; 
    333333  } 
    334    
     334 
    335335  /** Enables/Disables CacheManager options in option window.*/ 
    336336  private void enableCache(boolean enable) { 
     
    338338    tCheck.setEnabled(enable); 
    339339    cCheck.setEnabled(enable); 
    340      
     340 
    341341    modeBox.setEnabled(enable); 
    342342    stratBox.setEnabled(enable); 
     
    344344    midBox.setEnabled(enable); 
    345345    lowBox.setEnabled(enable); 
    346      
     346 
    347347    zBSpin.setEnabled(enable); 
    348348    zFSpin.setEnabled(enable); 
     
    351351    cBSpin.setEnabled(enable); 
    352352    cFSpin.setEnabled(enable); 
    353      
     353 
    354354    resetBtn.setEnabled(enable); 
    355355  } 
     
    360360    if(update) { 
    361361      Object source = e.getSource(); 
    362        
     362 
    363363      if (source == modeBox) { 
    364364        if(modeBox.getSelectedIndex() == 0) 
     
    390390        manager.setPriority(CacheManager.T_AXIS,CacheManager.Z_AXIS, 
    391391          CacheManager.C_AXIS); 
    392          
     392 
    393393        Integer zeroI = new Integer(0); 
    394394        Integer twentyI = new Integer(20); 
     
    398398        tBSpin.setValue(zeroI); 
    399399        cFSpin.setValue(zeroI); 
    400         cBSpin.setValue(zeroI);  
     400        cBSpin.setValue(zeroI); 
    401401        manager.setSize(0,0,0,20,0,0); 
    402          
     402 
    403403        oldTop = topBox.getSelectedIndex(); 
    404404        oldMid = midBox.getSelectedIndex(); 
     
    421421          update = true; 
    422422        } 
    423          
     423 
    424424        oldTop = newTop; 
    425425        manager.setPriority(getConv(topBox.getSelectedIndex()), 
    426426         getConv(midBox.getSelectedIndex()), 
    427          getConv(lowBox.getSelectedIndex()));         
     427         getConv(lowBox.getSelectedIndex())); 
    428428      } 
    429429      else if (source == midBox) { 
     
    442442          update = true; 
    443443        } 
    444          
     444 
    445445        oldMid = newMid; 
    446446        manager.setPriority(getConv(topBox.getSelectedIndex()), 
    447447         getConv(midBox.getSelectedIndex()), 
    448          getConv(lowBox.getSelectedIndex()));         
     448         getConv(lowBox.getSelectedIndex())); 
    449449      } 
    450450      else if (source == lowBox) { 
     
    463463          update = true; 
    464464        } 
    465          
     465 
    466466        oldLow = newLow; 
    467467        manager.setPriority(getConv(topBox.getSelectedIndex()), 
    468468         getConv(midBox.getSelectedIndex()), 
    469          getConv(lowBox.getSelectedIndex()));         
     469         getConv(lowBox.getSelectedIndex())); 
    470470      } 
    471471    } 
    472472  } 
    473    
     473 
    474474  public void itemStateChanged(ItemEvent e) { 
    475475    if(update) { 
    476476      Object source = e.getItemSelectable(); 
    477        
     477 
    478478      //if this is the only selected checkbox, leave it selected 
    479479      if (source == zCheck && e.getStateChange() == ItemEvent.DESELECTED && 
     
    501501        return; 
    502502      } 
    503      
     503 
    504504      int zState = 0x00,tState = 0x00,cState = 0x00; 
    505        
     505 
    506506      if (zCheck.isSelected()) zState = CacheManager.Z_AXIS; 
    507507      if (tCheck.isSelected()) tState = CacheManager.T_AXIS; 
    508508      if (cCheck.isSelected()) cState = CacheManager.C_AXIS; 
    509        
     509 
    510510      int finalState = (zState | tState | cState); 
    511511      manager.setAxis(finalState); 
Note: See TracChangeset for help on using the changeset viewer.