org.eclipse.ui.views.properties.tabbed_3.5.200.v20110928-1505

16:48:27.163 INFO  jd.cli.Main - Decompiling org.eclipse.ui.views.properties.tabbed_3.5.200.v20110928-1505.jar
package org.eclipse.ui.internal.views.properties.tabbed;

import org.eclipse.ui.plugin.AbstractUIPlugin;

public class TabbedPropertyViewPlugin
  extends AbstractUIPlugin
{
  private static TabbedPropertyViewPlugin plugin;
  
  public TabbedPropertyViewPlugin()
  {
    plugin = this;
  }
  
  public static TabbedPropertyViewPlugin getPlugin()
  {
    return plugin;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed;

public final class TabbedPropertyViewStatusCodes
{
  public static final int OK = 0;
  public static final int NO_TAB_ERROR = 1;
  public static final int SECTION_ERROR = 2;
  public static final int TAB_ERROR = 3;
  public static final int CONTRIBUTOR_ERROR = 4;
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewStatusCodes
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.l10n;

import org.eclipse.osgi.util.NLS;

public final class TabbedPropertyMessages
  extends NLS
{
  private static final String BUNDLE_NAME = "org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages";
  public static String SectionDescriptor_Section_error;
  public static String SectionDescriptor_class_not_found_error;
  public static String TabDescriptor_Tab_error;
  public static String TabDescriptor_Tab_unknown_category;
  public static String TabbedPropertyRegistry_Non_existing_tab;
  public static String TabbedPropertyRegistry_contributor_error;
  public static String TabbedPropertyList_properties_not_available;
  
  static
  {
    NLS.initializeMessages("org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages", TabbedPropertyMessages.class);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.viewers.ContentViewer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.part.IContributedContentsView;
import org.eclipse.ui.views.properties.IPropertySheetPage;
import org.eclipse.ui.views.properties.tabbed.AbstractOverridableTabListPropertySection;
import org.eclipse.ui.views.properties.tabbed.AbstractTabDescriptor;
import org.eclipse.ui.views.properties.tabbed.IOverridableTabListContentProvider;
import org.eclipse.ui.views.properties.tabbed.ISection;
import org.eclipse.ui.views.properties.tabbed.ITabDescriptor;
import org.eclipse.ui.views.properties.tabbed.ITabItem;
import org.eclipse.ui.views.properties.tabbed.ITabSelectionListener;
import org.eclipse.ui.views.properties.tabbed.TabContents;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;

class OverridableTabListContentProvider
  extends TabListContentProvider
  implements IOverridableTabListContentProvider, ITabSelectionListener
{
  private TabbedPropertySheetPage tabbedPropertySheetPage;
  private TabbedPropertyViewer tabbedPropertyViewer;
  
  public OverridableTabListContentProvider(TabbedPropertyRegistry registry)
  {
    super(registry);
  }
  
  public Object[] getElements(Object inputElement)
  {
    if (tabbedPropertySheetPage.getCurrentTab() == null) {
      return registry.getTabDescriptors(currentPart, 
        (ISelection)inputElement);
    }
    return getOverrideTabs(inputElement);
  }
  
  public void dispose()
  {
    stopListening();
    tabbedPropertyViewer = null;
    currentPart = null;
    tabbedPropertySheetPage = null;
  }
  
  public void inputChanged(Viewer viewer, Object oldInput, Object newInput)
  {
    if (tabbedPropertyViewer == null)
    {
      Assert.isTrue(viewer instanceof TabbedPropertyViewer);
      init((TabbedPropertyViewer)viewer);
    }
  }
  
  private void init(TabbedPropertyViewer newTabbedPropertyViewer)
  {
    tabbedPropertyViewer = newTabbedPropertyViewer;
    currentPart = tabbedPropertyViewer.getWorkbenchPart();
    if (currentPart.getAdapter(IPropertySheetPage.class) != null)
    {
      tabbedPropertySheetPage = 
        ((TabbedPropertySheetPage)currentPart.getAdapter(IPropertySheetPage.class));
    }
    else
    {
      IContributedContentsView view = (IContributedContentsView)currentPart
        .getAdapter(IContributedContentsView.class);
      if (view != null)
      {
        IWorkbenchPart part = view.getContributingPart();
        if (part != null) {
          tabbedPropertySheetPage = 
            ((TabbedPropertySheetPage)part.getAdapter(IPropertySheetPage.class));
        }
      }
    }
    Assert.isNotNull(
      tabbedPropertySheetPage, 
      "DynamicTabListContentProvider could not find the TabbedPropertySheetPage for the active part");
    startListening();
  }
  
  private void startListening()
  {
    tabbedPropertySheetPage.addTabSelectionListener(this);
  }
  
  private void stopListening()
  {
    tabbedPropertySheetPage.removeTabSelectionListener(this);
  }
  
  public void tabSelected(ITabDescriptor tabDescriptor)
  {
    AbstractOverridableTabListPropertySection section = getOverridableTabListPropertySection();
    Assert.isNotNull(section);
    int selectedIndex = tabbedPropertyViewer.getSelectionIndex();
    section.selectTab(selectedIndex);
  }
  
  private void setSelectedTab()
  {
    TabDescriptor currentSelectedTabInList = null;
    IStructuredSelection selectionFromList = (IStructuredSelection)tabbedPropertyViewer
      .getSelection();
    if (!selectionFromList.equals(StructuredSelection.EMPTY)) {
      currentSelectedTabInList = (TabDescriptor)selectionFromList
        .getFirstElement();
    }
    AbstractOverridableTabListPropertySection section = getOverridableTabListPropertySection();
    if (section == null)
    {
      if (currentSelectedTabInList == null)
      {
        TabDescriptor newSelectedTab = (TabDescriptor)tabbedPropertyViewer
          .getElementAt(0);
        if (newSelectedTab != null) {
          tabbedPropertyViewer.setSelection(new StructuredSelection(
            newSelectedTab), true);
        }
      }
      return;
    }
    ITabItem[] dynamicTabItems = section.getTabs();
    if (dynamicTabItems == null) {
      return;
    }
    int selectedTabIndex = -1;
    for (int i = 0; i < dynamicTabItems.length; i++) {
      if (dynamicTabItems[i].isSelected()) {
        selectedTabIndex = i;
      }
    }
    if ((currentSelectedTabInList == null) || 
      (!currentSelectedTabInList.getText().equals(
      dynamicTabItems[selectedTabIndex].getText())))
    {
      TabDescriptor newSelectedTab = (TabDescriptor)tabbedPropertyViewer
        .getElementAt(selectedTabIndex);
      tabbedPropertyViewer.setSelection(new StructuredSelection(
        newSelectedTab), true);
    }
  }
  
  private ITabDescriptor[] getOverrideTabs(Object inputElement)
  {
    ITabDescriptor[] tabDescriptors = registry.getTabDescriptors(
      currentPart, (ISelection)inputElement);
    if (tabDescriptors == TabbedPropertyRegistry.EMPTY_DESCRIPTOR_ARRAY) {
      return tabDescriptors;
    }
    AbstractOverridableTabListPropertySection section = getOverridableTabListPropertySection();
    Assert.isNotNull(section);
    ITabItem[] tabItems = section.getTabs();
    if (tabItems == null) {
      return tabDescriptors;
    }
    ITabDescriptor[] overrideTabDescriptors = new ITabDescriptor[tabItems.length];
    TabDescriptor target = (TabDescriptor)tabDescriptors[0];
    for (int i = 0; i < tabItems.length; i++)
    {
      TabDescriptor cloneTabDescriptor = (TabDescriptor)target.clone();
      cloneTabDescriptor.setLabel(tabItems[i].getText());
      cloneTabDescriptor.setImage(tabItems[i].getImage());
      cloneTabDescriptor.setIndented(tabItems[i].isIndented());
      cloneTabDescriptor.setSelected(tabItems[i].isSelected());
      overrideTabDescriptors[i] = cloneTabDescriptor;
    }
    return overrideTabDescriptors;
  }
  
  public void overrideTabs()
  {
    stopListening();
    Object input = tabbedPropertyViewer.getInput();
    tabbedPropertyViewer.setInput(input);
    setSelectedTab();
    startListening();
  }
  
  private AbstractOverridableTabListPropertySection getOverridableTabListPropertySection()
  {
    TabContents tab = tabbedPropertySheetPage.getCurrentTab();
    Assert.isNotNull(tab);
    if (tab != null)
    {
      ISection section = tab.getSectionAtIndex(0);
      if ((section instanceof AbstractOverridableTabListPropertySection)) {
        return (AbstractOverridableTabListPropertySection)section;
      }
    }
    return null;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.OverridableTabListContentProvider
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import com.ibm.icu.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.viewers.IFilter;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;
import org.eclipse.ui.views.properties.tabbed.AbstractSectionDescriptor;
import org.eclipse.ui.views.properties.tabbed.ISection;
import org.eclipse.ui.views.properties.tabbed.ITypeMapper;

public class SectionDescriptor
  extends AbstractSectionDescriptor
{
  private static final String ATT_ID = "id";
  private static final String ATT_TARGET_TAB = "tab";
  private static final String ATT_AFTER_SECTION = "afterSection";
  private static final String ATT_CLASS = "class";
  private static final String ATT_SECTION_FILTER = "filter";
  private static final String ATT_SECTION_ENABLES_FOR = "enablesFor";
  private static final String ATT_INPUT_TYPE = "type";
  private static final String ELEMENT_INPUT = "input";
  private String id;
  private String targetTab;
  private String afterSection;
  private ArrayList inputTypes;
  private IFilter filter;
  private int enablesFor = -1;
  private IConfigurationElement configurationElement;
  
  protected SectionDescriptor(IConfigurationElement configurationElement, ITypeMapper typeMapper)
  {
    super(typeMapper);
    this.configurationElement = configurationElement;
    
    id = getConfigurationElement().getAttribute("id");
    targetTab = getConfigurationElement().getAttribute("tab");
    afterSection = getConfigurationElement()
      .getAttribute("afterSection");
    if (getConfigurationElement().getAttribute("enablesFor") != null)
    {
      String enablesForStr = getConfigurationElement().getAttribute(
        "enablesFor");
      int enablesForTest = Integer.parseInt(enablesForStr);
      if (enablesForTest > 0) {
        enablesFor = enablesForTest;
      }
    }
    if ((id == null) || (targetTab == null)) {
      handleSectionError(null);
    }
  }
  
  private void handleSectionError(CoreException exception)
  {
    String pluginId = getConfigurationElement().getDeclaringExtension()
      .getNamespaceIdentifier();
    String message = TabbedPropertyMessages.SectionDescriptor_Section_error;
    if (exception == null) {
      message = MessageFormat.format(
        TabbedPropertyMessages.SectionDescriptor_Section_error, 
        new Object[] { pluginId });
    } else {
      message = 
        MessageFormat.format(
        TabbedPropertyMessages.SectionDescriptor_class_not_found_error, 
        new Object[] { pluginId });
    }
    IStatus status = new Status(4, pluginId, 
      2, message, exception);
    TabbedPropertyViewPlugin.getPlugin().getLog().log(status);
  }
  
  public String getId()
  {
    return id;
  }
  
  public IFilter getFilter()
  {
    if (filter == null) {
      try
      {
        if (getConfigurationElement().getAttribute("filter") != null) {
          filter = 
            ((IFilter)configurationElement.createExecutableExtension("filter"));
        }
      }
      catch (CoreException exception)
      {
        handleSectionError(exception);
      }
    }
    return filter;
  }
  
  public int getEnablesFor()
  {
    return enablesFor;
  }
  
  public String getTargetTab()
  {
    return targetTab;
  }
  
  public String getAfterSection()
  {
    if (afterSection == null) {
      return super.getAfterSection();
    }
    return afterSection;
  }
  
  public ISection getSectionClass()
  {
    ISection section = null;
    try
    {
      section = (ISection)getConfigurationElement()
        .createExecutableExtension("class");
    }
    catch (CoreException exception)
    {
      handleSectionError(exception);
    }
    return section;
  }
  
  public List getInputTypes()
  {
    if (inputTypes == null)
    {
      inputTypes = new ArrayList();
      IConfigurationElement[] elements = getConfigurationElement()
        .getChildren("input");
      for (int i = 0; i < elements.length; i++)
      {
        IConfigurationElement element = elements[i];
        inputTypes.add(element.getAttribute("type"));
      }
    }
    return inputTypes;
  }
  
  public String toString()
  {
    return getId();
  }
  
  private IConfigurationElement getConfigurationElement()
  {
    return configurationElement;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.SectionDescriptor
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import com.ibm.icu.text.MessageFormat;
import java.util.List;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Resource;
import org.eclipse.ui.internal.views.properties.tabbed.TabbedPropertyViewPlugin;
import org.eclipse.ui.internal.views.properties.tabbed.l10n.TabbedPropertyMessages;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.eclipse.ui.views.properties.tabbed.AbstractTabDescriptor;
import org.eclipse.ui.views.properties.tabbed.ISectionDescriptor;

public class TabDescriptor
  extends AbstractTabDescriptor
{
  private static final String ATT_ID = "id";
  private static final String ATT_LABEL = "label";
  private static final String ATT_IMAGE = "image";
  private static final String ATT_INDENTED = "indented";
  private static final String ATT_CATEGORY = "category";
  private static final String ATT_AFTER_TAB = "afterTab";
  private static final String TAB_ERROR = TabbedPropertyMessages.TabDescriptor_Tab_error;
  private String id;
  private String label;
  private Image image;
  private boolean selected;
  private boolean indented;
  private String category;
  private String afterTab;
  
  public TabDescriptor(IConfigurationElement configurationElement)
  {
    if (configurationElement != null)
    {
      id = configurationElement.getAttribute("id");
      label = configurationElement.getAttribute("label");
      String imageString = configurationElement.getAttribute("image");
      if (imageString != null) {
        image = AbstractUIPlugin.imageDescriptorFromPlugin(
          configurationElement.getDeclaringExtension()
          .getNamespaceIdentifier(), imageString)
          .createImage();
      }
      String indentedString = configurationElement
        .getAttribute("indented");
      indented = ((indentedString != null) && (indentedString.equals("true")));
      category = configurationElement.getAttribute("category");
      afterTab = configurationElement.getAttribute("afterTab");
      if ((id == null) || (label == null) || (category == null)) {
        handleTabError(configurationElement, null);
      }
    }
    selected = false;
  }
  
  public String getId()
  {
    return id;
  }
  
  public String getLabel()
  {
    return label;
  }
  
  public String getAfterTab()
  {
    if (afterTab == null) {
      return super.getAfterTab();
    }
    return afterTab;
  }
  
  public String getCategory()
  {
    return category;
  }
  
  protected boolean append(ISectionDescriptor target)
  {
    if (!target.getTargetTab().equals(id)) {
      return false;
    }
    if (insertSectionDescriptor(target)) {
      return true;
    }
    getSectionDescriptors().add(target);
    return true;
  }
  
  private boolean insertSectionDescriptor(ISectionDescriptor target)
  {
    if (target.getAfterSection().equals("top"))
    {
      getSectionDescriptors().add(0, target);
      return true;
    }
    for (int i = 0; i < getSectionDescriptors().size(); i++)
    {
      ISectionDescriptor descriptor = (ISectionDescriptor)getSectionDescriptors()
        .get(i);
      if (target.getAfterSection().equals(descriptor.getId()))
      {
        getSectionDescriptors().add(i + 1, target);
        return true;
      }
      if (descriptor.getAfterSection().equals(target.getId()))
      {
        getSectionDescriptors().add(i, target);
        return true;
      }
    }
    return false;
  }
  
  public String toString()
  {
    return getId();
  }
  
  private void handleTabError(IConfigurationElement configurationElement, CoreException exception)
  {
    String pluginId = configurationElement.getDeclaringExtension()
      .getNamespaceIdentifier();
    String message = MessageFormat.format(TAB_ERROR, 
      new Object[] { pluginId });
    IStatus status = new Status(4, pluginId, 
      3, message, exception);
    TabbedPropertyViewPlugin.getPlugin().getLog().log(status);
  }
  
  protected void setImage(Image image)
  {
    this.image = image;
  }
  
  protected void setIndented(boolean indented)
  {
    this.indented = indented;
  }
  
  protected void setSelected(boolean selected)
  {
    this.selected = selected;
  }
  
  protected void setLabel(String label)
  {
    this.label = label;
  }
  
  public Image getImage()
  {
    return image;
  }
  
  public boolean isSelected()
  {
    return selected;
  }
  
  public boolean isIndented()
  {
    return indented;
  }
  
  public String getText()
  {
    return label;
  }
  
  public void dispose()
  {
    if (image != null)
    {
      image.dispose();
      image = null;
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabDescriptor
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IWorkbenchPart;

public class TabListContentProvider
  implements IStructuredContentProvider
{
  protected TabbedPropertyRegistry registry;
  protected IWorkbenchPart currentPart;
  
  public TabListContentProvider(TabbedPropertyRegistry registry)
  {
    this.registry = registry;
  }
  
  public Object[] getElements(Object inputElement)
  {
    Assert.isTrue(inputElement instanceof ISelection);
    return registry
      .getTabDescriptors(currentPart, (ISelection)inputElement);
  }
  
  public void dispose() {}
  
  public void inputChanged(Viewer viewer, Object oldInput, Object newInput)
  {
    currentPart = ((TabbedPropertyViewer)viewer).getWorkbenchPart();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabListContentProvider
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetWidgetFactory;

public class TabbedPropertyComposite
  extends Composite
{
  private TabbedPropertySheetWidgetFactory factory;
  private Composite mainComposite;
  private Composite leftComposite;
  private ScrolledComposite scrolledComposite;
  private Composite tabComposite;
  private TabbedPropertyTitle title;
  private TabbedPropertyList listComposite;
  private boolean displayTitle;
  
  public TabbedPropertyComposite(Composite parent, TabbedPropertySheetWidgetFactory factory, boolean displayTitle)
  {
    super(parent, 524288);
    this.factory = factory;
    this.displayTitle = displayTitle;
    
    createMainComposite();
  }
  
  protected void createMainComposite()
  {
    mainComposite = factory.createComposite(this, 524288);
    mainComposite.setLayout(new FormLayout());
    FormData formData = new FormData();
    left = new FormAttachment(0, 0);
    right = new FormAttachment(100, 0);
    top = new FormAttachment(0, 0);
    bottom = new FormAttachment(100, 0);
    mainComposite.setLayoutData(formData);
    
    createMainContents();
  }
  
  protected void createMainContents()
  {
    if (displayTitle)
    {
      title = new TabbedPropertyTitle(mainComposite, factory);
      
      FormData data = new FormData();
      left = new FormAttachment(0, 0);
      right = new FormAttachment(100, 0);
      top = new FormAttachment(0, 0);
      title.setLayoutData(data);
    }
    leftComposite = factory.createComposite(mainComposite, 524288);
    leftComposite.setLayout(new FormLayout());
    
    scrolledComposite = factory.createScrolledComposite(mainComposite, 525056);
    
    FormData formData = new FormData();
    left = new FormAttachment(leftComposite, 0);
    right = new FormAttachment(100, 0);
    if (displayTitle) {
      top = new FormAttachment(title, 0);
    } else {
      top = new FormAttachment(0, 0);
    }
    bottom = new FormAttachment(100, 0);
    scrolledComposite.setLayoutData(formData);
    
    formData = new FormData();
    left = new FormAttachment(0, 0);
    right = new FormAttachment(scrolledComposite, 0);
    if (displayTitle) {
      top = new FormAttachment(title, 0);
    } else {
      top = new FormAttachment(0, 0);
    }
    bottom = new FormAttachment(100, 0);
    leftComposite.setLayoutData(formData);
    
    tabComposite = factory.createComposite(scrolledComposite, 524288);
    tabComposite.setLayout(new FormLayout());
    
    scrolledComposite.setContent(tabComposite);
    scrolledComposite.setAlwaysShowScrollBars(false);
    scrolledComposite.setExpandVertical(true);
    scrolledComposite.setExpandHorizontal(true);
    
    listComposite = new TabbedPropertyList(leftComposite, factory);
    formData = new FormData();
    left = new FormAttachment(0, 0);
    right = new FormAttachment(100, 0);
    top = new FormAttachment(0, 0);
    bottom = new FormAttachment(100, 0);
    listComposite.setLayoutData(formData);
  }
  
  public TabbedPropertyList getList()
  {
    return listComposite;
  }
  
  public TabbedPropertyTitle getTitle()
  {
    return title;
  }
  
  public Composite getTabComposite()
  {
    return tabComposite;
  }
  
  public ScrolledComposite getScrolledComposite()
  {
    return scrolledComposite;
  }
  
  protected TabbedPropertySheetWidgetFactory getFactory()
  {
    return factory;
  }
  
  public void dispose()
  {
    listComposite.dispose();
    if (displayTitle) {
      title.dispose();
    }
    super.dispose();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyComposite
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;

class TabbedPropertyList$1
  implements PaintListener
{
  final TabbedPropertyList.ListElement this$1;
  
  TabbedPropertyList$1(TabbedPropertyList.ListElement paramListElement)
  {
    this$1 = paramListElement;
  }
  
  public void paintControl(PaintEvent e)
  {
    TabbedPropertyList.ListElement.access$0(this$1, e);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.1
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;

class TabbedPropertyList$10
  extends ControlAdapter
{
  final TabbedPropertyList this$0;
  
  TabbedPropertyList$10(TabbedPropertyList paramTabbedPropertyList)
  {
    this$0 = paramTabbedPropertyList;
  }
  
  public void controlResized(ControlEvent e)
  {
    TabbedPropertyList.access$27(this$0);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.10
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.widgets.Control;

class TabbedPropertyList$11
  implements TraverseListener
{
  final TabbedPropertyList this$0;
  
  TabbedPropertyList$11(TabbedPropertyList paramTabbedPropertyList)
  {
    this$0 = paramTabbedPropertyList;
  }
  
  public void keyTraversed(TraverseEvent e)
  {
    if ((detail == 32) || 
      (detail == 64))
    {
      int nMax = TabbedPropertyList.access$20(this$0).length - 1;
      int nCurrent = this$0.getSelectionIndex();
      if (detail == 32)
      {
        nCurrent--;
        nCurrent = Math.max(0, nCurrent);
      }
      else if (detail == 64)
      {
        nCurrent++;
        nCurrent = Math.min(nCurrent, nMax);
      }
      this$0.select(nCurrent);
      this$0.redraw();
    }
    else
    {
      doit = true;
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.11
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.accessibility.AccessibleAdapter;
import org.eclipse.swt.accessibility.AccessibleEvent;
import org.eclipse.ui.views.properties.tabbed.ITabItem;

class TabbedPropertyList$12
  extends AccessibleAdapter
{
  final TabbedPropertyList this$0;
  
  TabbedPropertyList$12(TabbedPropertyList paramTabbedPropertyList)
  {
    this$0 = paramTabbedPropertyList;
  }
  
  public void getName(AccessibleEvent e)
  {
    if (this$0.getSelectionIndex() != -1) {
      result = TabbedPropertyList.access$20(this$0)[this$0.getSelectionIndex()].getTabItem()
        .getText();
    }
  }
  
  public void getHelp(AccessibleEvent e)
  {
    if (this$0.getSelectionIndex() != -1) {
      result = TabbedPropertyList.access$20(this$0)[this$0.getSelectionIndex()].getTabItem()
        .getText();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.12
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.accessibility.AccessibleControlAdapter;
import org.eclipse.swt.accessibility.AccessibleControlEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;

class TabbedPropertyList$13
  extends AccessibleControlAdapter
{
  final TabbedPropertyList this$0;
  
  TabbedPropertyList$13(TabbedPropertyList paramTabbedPropertyList)
  {
    this$0 = paramTabbedPropertyList;
  }
  
  public void getChildAtPoint(AccessibleControlEvent e)
  {
    Point pt = this$0.toControl(new Point(x, y));
    childID = (this$0.getBounds().contains(pt) ? -1 : 
      -2);
  }
  
  public void getLocation(AccessibleControlEvent e)
  {
    if (this$0.getSelectionIndex() != -1)
    {
      Rectangle location = TabbedPropertyList.access$20(this$0)[this$0.getSelectionIndex()]
        .getBounds();
      Point pt = this$0.toDisplay(new Point(x, y));
      x = x;
      y = y;
      width = width;
      height = height;
    }
  }
  
  public void getChildCount(AccessibleControlEvent e)
  {
    detail = 0;
  }
  
  public void getRole(AccessibleControlEvent e)
  {
    detail = 37;
  }
  
  public void getState(AccessibleControlEvent e)
  {
    detail = 3145734;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.13
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.accessibility.Accessible;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

class TabbedPropertyList$14
  implements Listener
{
  final TabbedPropertyList this$0;
  private final Accessible val$accessible;
  
  TabbedPropertyList$14(TabbedPropertyList paramTabbedPropertyList, Accessible paramAccessible)
  {
    this$0 = paramTabbedPropertyList;val$accessible = paramAccessible;
  }
  
  public void handleEvent(Event event)
  {
    if (this$0.isFocusControl()) {
      val$accessible.setFocus(-1);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.14
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.accessibility.Accessible;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

class TabbedPropertyList$15
  implements Listener
{
  final TabbedPropertyList this$0;
  private final Accessible val$accessible;
  
  TabbedPropertyList$15(TabbedPropertyList paramTabbedPropertyList, Accessible paramAccessible)
  {
    this$0 = paramTabbedPropertyList;val$accessible = paramAccessible;
  }
  
  public void handleEvent(Event event)
  {
    val$accessible.setFocus(-1);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.15
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

class TabbedPropertyList$2
  extends MouseAdapter
{
  final TabbedPropertyList.ListElement this$1;
  
  TabbedPropertyList$2(TabbedPropertyList.ListElement paramListElement)
  {
    this$1 = paramListElement;
  }
  
  public void mouseUp(MouseEvent e)
  {
    if (!TabbedPropertyList.ListElement.access$1(this$1))
    {
      TabbedPropertyList.ListElement.access$5(this$1).select(TabbedPropertyList.access$0(TabbedPropertyList.ListElement.access$5(this$1), this$1));
      
      Composite tabbedPropertyComposite = this$1.getParent();
      while (!(tabbedPropertyComposite instanceof TabbedPropertyComposite)) {
        tabbedPropertyComposite = 
          tabbedPropertyComposite.getParent();
      }
      tabbedPropertyComposite.setFocus();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.2
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.widgets.Control;

class TabbedPropertyList$3
  implements MouseMoveListener
{
  final TabbedPropertyList.ListElement this$1;
  
  TabbedPropertyList$3(TabbedPropertyList.ListElement paramListElement)
  {
    this$1 = paramListElement;
  }
  
  public void mouseMove(MouseEvent e)
  {
    if (!TabbedPropertyList.ListElement.access$2(this$1))
    {
      TabbedPropertyList.ListElement.access$3(this$1, true);
      this$1.redraw();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.3
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseTrackAdapter;
import org.eclipse.swt.widgets.Control;

class TabbedPropertyList$4
  extends MouseTrackAdapter
{
  final TabbedPropertyList.ListElement this$1;
  
  TabbedPropertyList$4(TabbedPropertyList.ListElement paramListElement)
  {
    this$1 = paramListElement;
  }
  
  public void mouseExit(MouseEvent e)
  {
    TabbedPropertyList.ListElement.access$3(this$1, false);
    this$1.redraw();
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.4
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;

class TabbedPropertyList$5
  implements PaintListener
{
  final TabbedPropertyList.TopNavigationElement this$1;
  
  TabbedPropertyList$5(TabbedPropertyList.TopNavigationElement paramTopNavigationElement)
  {
    this$1 = paramTopNavigationElement;
  }
  
  public void paintControl(PaintEvent e)
  {
    TabbedPropertyList.TopNavigationElement.access$0(this$1, e);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.5
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.widgets.Control;

class TabbedPropertyList$6
  extends MouseAdapter
{
  final TabbedPropertyList.TopNavigationElement this$1;
  
  TabbedPropertyList$6(TabbedPropertyList.TopNavigationElement paramTopNavigationElement)
  {
    this$1 = paramTopNavigationElement;
  }
  
  public void mouseUp(MouseEvent e)
  {
    if (TabbedPropertyList.access$11(TabbedPropertyList.TopNavigationElement.access$1(this$1)))
    {
      TabbedPropertyList tmp20_17 = TabbedPropertyList.TopNavigationElement.access$1(this$1);TabbedPropertyList.access$13(tmp20_17, TabbedPropertyList.access$12(tmp20_17) - 1);
      if (TabbedPropertyList.access$14(TabbedPropertyList.TopNavigationElement.access$1(this$1)) != 0)
      {
        TabbedPropertyList tmp49_46 = TabbedPropertyList.TopNavigationElement.access$1(this$1);TabbedPropertyList.access$15(tmp49_46, TabbedPropertyList.access$14(tmp49_46) - 1);
      }
      TabbedPropertyList.access$16(TabbedPropertyList.TopNavigationElement.access$1(this$1));
      TabbedPropertyList.access$17(TabbedPropertyList.TopNavigationElement.access$1(this$1)).redraw();
      TabbedPropertyList.access$18(TabbedPropertyList.TopNavigationElement.access$1(this$1)).redraw();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.6
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;

class TabbedPropertyList$7
  implements PaintListener
{
  final TabbedPropertyList.BottomNavigationElement this$1;
  
  TabbedPropertyList$7(TabbedPropertyList.BottomNavigationElement paramBottomNavigationElement)
  {
    this$1 = paramBottomNavigationElement;
  }
  
  public void paintControl(PaintEvent e)
  {
    TabbedPropertyList.BottomNavigationElement.access$0(this$1, e);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.7
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.widgets.Control;

class TabbedPropertyList$8
  extends MouseAdapter
{
  final TabbedPropertyList.BottomNavigationElement this$1;
  
  TabbedPropertyList$8(TabbedPropertyList.BottomNavigationElement paramBottomNavigationElement)
  {
    this$1 = paramBottomNavigationElement;
  }
  
  public void mouseUp(MouseEvent e)
  {
    if (TabbedPropertyList.access$23(TabbedPropertyList.BottomNavigationElement.access$1(this$1)))
    {
      TabbedPropertyList tmp20_17 = TabbedPropertyList.BottomNavigationElement.access$1(this$1);TabbedPropertyList.access$15(tmp20_17, TabbedPropertyList.access$14(tmp20_17) + 1);
      if (TabbedPropertyList.access$12(TabbedPropertyList.BottomNavigationElement.access$1(this$1)) != TabbedPropertyList.access$20(TabbedPropertyList.BottomNavigationElement.access$1(this$1)).length - 1)
      {
        TabbedPropertyList tmp62_59 = TabbedPropertyList.BottomNavigationElement.access$1(this$1);TabbedPropertyList.access$13(tmp62_59, TabbedPropertyList.access$12(tmp62_59) + 1);
      }
      TabbedPropertyList.access$16(TabbedPropertyList.BottomNavigationElement.access$1(this$1));
      TabbedPropertyList.access$17(TabbedPropertyList.BottomNavigationElement.access$1(this$1)).redraw();
      TabbedPropertyList.access$18(TabbedPropertyList.BottomNavigationElement.access$1(this$1)).redraw();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.8
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.widgets.Control;

class TabbedPropertyList$9
  implements FocusListener
{
  final TabbedPropertyList this$0;
  
  TabbedPropertyList$9(TabbedPropertyList paramTabbedPropertyList)
  {
    this$0 = paramTabbedPropertyList;
  }
  
  public void focusGained(FocusEvent e)
  {
    TabbedPropertyList.access$26(this$0, true);
    int i = this$0.getSelectionIndex();
    if (i >= 0) {
      TabbedPropertyList.access$20(this$0)[i].redraw();
    }
  }
  
  public void focusLost(FocusEvent e)
  {
    TabbedPropertyList.access$26(this$0, false);
    int i = this$0.getSelectionIndex();
    if (i >= 0) {
      TabbedPropertyList.access$20(this$0)[i].redraw();
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.ui.internal.views.properties.tabbed.view.TabbedPropertyList.9
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.ui.internal.views.properties.tabbed.view;

import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

public class TabbedPropertyList$BottomNavigationElement
  extends Canvas
{
  final TabbedPropertyList this$0;
  
  public TabbedPropertyList$BottomNavigationElement(TabbedPropert
1 2 3 4 5

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd