protected void handleMemberSelect(Widget item) {
	Object data = null;
	if (item != null)
		data = item.getData();
	if (data instanceof ICompilationUnit) {
		this.currentCU = (ICompilationUnit) data;
		problemsPane.setImage(CompareUI.getImage(this.currentCU.getResource()));
		String pattern = "Problems in file {0}";
		String title = MessageFormat.format(pattern, new Object[] { this.currentCU.getResource().getName() });
		problemsPane.setText(title);
		if (problemsTable != null) {
			problemsTable.setRedraw(false);
			problemsTable.removeAll();
			ConversionResult conversionResult = input.get(currentCU);
			for (String problem : conversionResult.getProblems()) {
				addProblemItem(problem);
			}
			problemsTable.setRedraw(true);
		}
	} else
		this.currentCU = null;
}
 

/**
 * Returns the shell for the given widget. If the widget doesn't represent
 * a SWT object that manage a shell, <code>null</code> is returned.
 * @param widget the widget
 *
 * @return the shell for the given widget
 */
public static Shell getShell(Widget widget) {
    if (widget instanceof Control) {
        return ((Control) widget).getShell();
    }
    if (widget instanceof Caret) {
        return ((Caret) widget).getParent().getShell();
    }
    if (widget instanceof DragSource) {
        return ((DragSource) widget).getControl().getShell();
    }
    if (widget instanceof DropTarget) {
        return ((DropTarget) widget).getControl().getShell();
    }
    if (widget instanceof Menu) {
        return ((Menu) widget).getParent().getShell();
    }
    if (widget instanceof ScrollBar) {
        return ((ScrollBar) widget).getParent().getShell();
    }

    return null;
}
 

/**
 * Walk up the MenuItems (in case they are nested) and find the parent {@link Menu}
 *
 * @param selectionEvent
 *            on the {@link MenuItem}
 * @return data associated with the parent {@link Menu}
 */
public static NatEventData getNatEventData(SelectionEvent selectionEvent) {
	Widget widget = selectionEvent.widget;
	if (widget == null || !(widget instanceof MenuItem)) {
		return null;
	}

	MenuItem menuItem = (MenuItem) widget;
	Menu parentMenu = menuItem.getParent();
	Object data = null;
	while (parentMenu != null) {
		if (parentMenu.getData() == null) {
			parentMenu = parentMenu.getParentMenu();
		} else {
			data = parentMenu.getData();
			break;
		}
	}

	return data != null ? (NatEventData) data : null;
}
 

@Override
public void handleEvent(Event e) {
    super.handleEvent(e);
    Widget source = e.widget;

    if (source == destinationBrowseButton) {
        handleDestinationBrowseButtonPressed();
    }

    if (source instanceof Combo) {
        String destination = ((Combo) source).getText();
        if (getDialogSettings() != null) {
            IDialogSettings section = getDialogSettings().getSection(DESTINATION_FILE);
            if (section == null) {
                section = getDialogSettings().addNewSection(DESTINATION_FILE);
            }
            section.put(DESTINATION_FILE, destination);
        }
    }
}
 

/**
 * Returns the shell for the given widget. If the widget doesn't represent a SWT object that manage a shell,
 * <code>null</code> is returned.
 * 
 * @param widget
 *            the widget
 * 
 * @return the shell for the given widget
 */
public static Shell getShell(Widget widget) {
	if (widget instanceof Control)
		return ((Control) widget).getShell();
	if (widget instanceof Caret)
		return ((Caret) widget).getParent().getShell();
	if (widget instanceof DragSource)
		return ((DragSource) widget).getControl().getShell();
	if (widget instanceof DropTarget)
		return ((DropTarget) widget).getControl().getShell();
	if (widget instanceof Menu)
		return ((Menu) widget).getParent().getShell();
	if (widget instanceof ScrollBar)
		return ((ScrollBar) widget).getParent().getShell();

	return null;
}
 

/**
 * Update the parent and children nodes after a checkstate change (e.g. recalculation of the grayed state, automatic
 * checking/unchecking of children)
 *
 * @param element
 *          the element that was checked/unchecked
 */
protected void doCheckStateChanged(final Object element) {
  final Widget item = findItem(element);
  if (item instanceof TreeItem) {
    final TreeItem treeItem = (TreeItem) item;
    updateChildrenItems(treeItem);

    final Item[] children = getChildren(item);
    if (children.length > 0) {
      boolean containsChecked = false;
      boolean containsUnchecked = false;
      for (final Item element2 : children) {
        final TreeItem curr = (TreeItem) element2;
        containsChecked |= curr.getChecked();
        containsUnchecked |= (!curr.getChecked() || curr.getGrayed());
      }
      treeItem.setChecked(containsChecked);
      treeItem.setGrayed(containsChecked && containsUnchecked);
    }
    updateParentItems(treeItem.getParentItem());
  }
}
 

/**
 * Creates a selection listener.
 */
public void createSelectionListener() {
    selectionListener = new SelectionAdapter() {
        @Override
        public void widgetSelected(SelectionEvent event) {
            Widget widget = event.widget;
            if (widget == addButton) {
                addPressed();
            } else if (widget == removeButton) {
                removePressed();
            } else if (widget == upButton) {
                upPressed();
            } else if (widget == downButton) {
                downPressed();
            } else if (widget == table) {
                selectionChanged();
            }
        }
    };
}
 

/**
 * Register to selection service to update button enablement
 * Register the Automatic Perspective switch part listener
 */
@Override
public void postWindowOpen() {
    IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
    configurer.addEditorAreaTransfer(EditorInputTransfer.getInstance());
    configurer.addEditorAreaTransfer(ResourceTransfer.getInstance());
    configurer.addEditorAreaTransfer(FileTransfer.getInstance());
    configurer.addEditorAreaTransfer(MarkerTransfer.getInstance());
    configurer.configureEditorAreaDropListener(new EditorAreaDropAdapter(
            configurer.getWindow()));

    final MWindow model = ((WorkbenchPage) window.getActivePage()).getWindowModel();
    model.getContext().get(EPartService.class).addPartListener(new AutomaticSwitchPerspectivePartListener());
    final Object widget = model.getWidget();
    if (widget instanceof Shell) {
        ((Widget) widget).setData(SWTBotConstants.SWTBOT_WIDGET_ID_KEY, SWTBotConstants.SWTBOT_ID_MAIN_SHELL);
    }
    // Replace ObjectActionContributorManager with filtered actions
    CustomObjectActionContributorManager.getManager();
}
 

@Override
public void widgetSelected(SelectionEvent e) {
	// An item is selected
	Widget item = e.item;
	if (item.getData(LAST_ITEM_LOADED) != null) {
		// The selected item must load another page.
		PageableController controller = super.getController(e.widget);
		if (controller.hasNextPage()) {
			// There is next page, increment the current page of the
			// controller
			controller.setCurrentPage(controller.getCurrentPage() + 1);
		}
		// Set as null the LAST_ITEM_LOADED flag to avoid loading data when
		// the item is selected (data is already loaded).
		item.setData(LAST_ITEM_LOADED, null);
	}
}
 

@Test(expected = ClassCastException.class)
public void frpBased() {
	Widget widget = (Widget) new Object();
	Observable<Event> keyDownStream = SwtRx.addListener(widget, SWT.KeyDown);
	keyDownStream.subscribe(e -> {
		// this is our chance to react
		System.out.println("keyCode=" + e.keyCode);
	});
	// this is how we do filtering
	keyDownStream.filter(e -> e.keyCode == 'q').subscribe(e -> {
		System.out.println("user wants to leave talk");
	});
	// this is how we do mapping
	keyDownStream.map(e -> e.keyCode | e.stateMask).subscribe(accel -> {
		System.out.println(Actions.getAcceleratorString(accel));
	});
}
 

/**
 * Detaches the popup dialogue if the name is same with the widget. Called
 * when clicking buttons manually.
 * 
 * @param widget
 *            the button widget
 * @return detach result
 */
protected boolean detachPopup( Widget widget )
{
	if ( widget instanceof Button
			&& popupShell != null
			&& !popupShell.isDisposed( )
			&& !isButtonSelected( ) )
	{
		getWizard( ).detachPopup( );
		popupShell = null;

		// Clear selection if user unselected the button.
		setCurrentPopupSelection( null );
		getParentTask( ).setPopupSelection( null );
		return true;
	}
	return false;
}
 

public Popup2(final IPopupProvider provider, final Widget... controls) {
	super(WorkbenchHelper.getShell(), PopupDialog.HOVER_SHELLSTYLE, false, false, false, false, false, null, null);
	this.provider = provider;
	final Shell parent = provider.getControllingShell();
	parent.addListener(SWT.Move, hide);
	parent.addListener(SWT.Resize, hide);
	parent.addListener(SWT.Close, hide);
	parent.addListener(SWT.Deactivate, hide);
	parent.addListener(SWT.Hide, hide);
	parent.addListener(SWT.Dispose, event -> close());
	for (final Widget c : controls) {
		if (c == null) {
			continue;
		}
		final TypedListener typedListener = new TypedListener(mtl);
		c.addListener(SWT.MouseEnter, typedListener);
		c.addListener(SWT.MouseExit, typedListener);
		c.addListener(SWT.MouseHover, typedListener);
	}
}
 

protected Item getChild(Widget widget, int index) {
	if (widget instanceof CTreeItem) {
		return ((CTreeItem) widget).getItem(index);
	}
	if (widget instanceof CTree) {
		return ctree.getItem(index);
	}
	return null;
}
 

@Override
public void unmapElement(Object element, Widget item) {

	if (element instanceof LogicalPackage && item instanceof Item) {
		LogicalPackage cp= (LogicalPackage) element;
		IPackageFragment[] fragments= cp.getFragments();
		for (int i= 0; i < fragments.length; i++) {
			IPackageFragment fragment= fragments[i];
			fResourceToItemsMapper.removeFromMap((Object)fragment, (Item)item);
		}
	}
	super.unmapElement(element, item);
}
 

public void testGalleryVirtualNew() {
	Gallery widget = createGallery(SWT.V_SCROLL | SWT.VIRTUAL);
	final ArrayList<Widget> setDataCalls = new ArrayList<>();
	widget.addListener(SWT.SetData, new Listener() {
		public void handleEvent(Event event) {
			setDataCalls.add(event.item);
		}
	});

	assertEquals(0, widget.getItemCount());

	GalleryItem item1 = new GalleryItem(widget, SWT.NONE);
	assertEquals(1, widget.getItemCount());
	assertEquals(item1, widget.getItem(0));
	assertFalse( setDataCalls.contains(item1));

	GalleryItem item2 = new GalleryItem(item1, SWT.NONE);
	assertEquals(1, widget.getItemCount());
	assertEquals(1, item1.getItemCount());
	assertEquals(item2, item1.getItem(0));
	assertFalse( setDataCalls.contains(item2));

	item1.dispose();
	assertEquals( 0, widget.getItemCount());
	assertTrue( item2.isDisposed());

	// Test removeAll
	item1 = new GalleryItem(widget, SWT.NONE);
	assertEquals(1, widget.getItemCount());
	assertEquals(item1, widget.getItem(0));
	assertFalse( setDataCalls.contains(item1));

	widget.removeAll();
	assertEquals(0, widget.getItemCount());

}
 

@Override
public void mouseDown(MouseEvent e) {
	Item item= (Item) ((Widget) e.getSource()).getData();
	// TODO for now, to make double click work: disable single click on the first item
	// disable later when the annotationlistener selectively handles input
	if (item != null && e.button == 1) // && item.fAnnotation != fInput.fAnnotations[0])
		item.defaultSelected(e);
}
 

private boolean controlDisposed( XulToolbarbutton button ) {
  if ( button.getManagedObject() instanceof Widget ) {
    Widget widget = (Widget) button.getManagedObject();
    return widget.isDisposed();
  }
  return false;
}
 

/**
 * @see org.eclipse.jface.viewers.ColumnViewer#getRowPartFromItem(org.eclipse
 *      .swt.widgets.Widget)
 */
protected ViewerRow getViewerRowFromItem(Widget item) {
	if (cachedRow == null) {
		cachedRow = new GalleryViewerRow((GalleryItem) item);
	} else {
		cachedRow.setItem((GalleryItem) item);
	}

	return cachedRow;
}
 

/** 
 * @see org.eclipse.jface.viewers.StructuredViewer#doUpdateItem(org.eclipse.swt.widgets.Widget, java.lang.Object, boolean)
 */
protected void doUpdateItem(Widget item, Object element, boolean fullMap) {
	Viewer viewer = getViewerForItem(pshelf.getSelection());
	if (viewer instanceof StructuredViewer) {
		ReflectionUtils.callMethod(viewer, "doUpdateItem", item, element, fullMap);
	}
}
 

@Override
public void mapElement(Object element, Widget item) {
	if (element instanceof LogicalPackage && item instanceof Item) {
		LogicalPackage cp= (LogicalPackage) element;
		IPackageFragment[] fragments= cp.getFragments();
		for (int i= 0; i < fragments.length; i++) {
			IPackageFragment fragment= fragments[i];
			fResourceToItemsMapper.addToMap(fragment, (Item) item);
		}
	}
	super.mapElement(element, item);
}
 

/**
 * {@inheritDoc}
 */
protected void updateColumnData(Widget column) {
	GridColumn gColumn = (GridColumn) column;
	Grid g = gColumn.getParent();

	if (!IS_GTK || g.getColumn(g.getColumnCount() - 1) != gColumn) {
		gColumn.setData(LAYOUT_DATA,
				new ColumnPixelData(gColumn.getWidth()));
		layout(g.getParent(), true);
	}
}
 

/**
 * {@inheritDoc}
 */
protected ViewerRow getViewerRowFromItem(Widget item) {
	if (cachedRow == null) {
		cachedRow = new TableComboViewerRow((TableItem) item);
	} else {
		cachedRow.setItem((TableItem) item);
	}

	return cachedRow;
}
 

/** {@inheritDoc} */
@Override
protected void doUpdateItem(Widget widget, Object element, boolean fullMap) {
    super.doUpdateItem(widget, element, fullMap);
    updateRowHeader(widget);
    if (autoPreferredHeight && !widget.isDisposed())
        ((GridItem) widget).pack();
}
 

protected void associate(Object element, Widget item) {
	Object data = item.getData();
	if (data != element) {
		if (data != null) {
			disassociate(item);
		}
		item.setData(element);
	}
	// Always map the element, even if data == element,
	// since unmapAllElements() can leave the map inconsistent
	// See bug 2741 for details.
	mapElement(element, item);
}
 

protected Widget doFindItem(Object element) {
	CContainerItem[] children = container.getItems();
	for(int i = 0; i < children.length; i++) {
		CContainerItem item = children[i];
		Object data = item.getData();
		if(data != null && equals(data, element))
			return item;
	}
	return null;
}
 

/** {@inheritDoc} */
protected Item[] getChildren(Widget o) {
	if (o instanceof GridItem) {
		return ((GridItem) o).getItems();
	}
	if (o instanceof Grid) {
		return ((Grid) o).getRootItems();
	}
	return null;
}
 

protected Widget doFindItem( Object element )
{
	if ( element == null )
		return null;

	for ( int i = 0, size = fBreadcrumbItems.size( ); i < size; i++ )
	{
		BreadcrumbItem item = (BreadcrumbItem) fBreadcrumbItems.get( i );
		if ( item.getData( ) == element || element.equals( item.getData( ) ) )
			return item;
	}

	return null;
}
 

@Override
protected void doUpdateItem(Widget widget, Object element, boolean fullMap) {
	super.doUpdateItem(widget, element, fullMap);
	if (! (widget instanceof TableItem))
		return;
	TableItem item= (TableItem)widget;
	IMemberActionInfo info= (IMemberActionInfo)element;
	item.setChecked(PullPushCheckboxTableViewer.getCheckState(info));
	Assert.isTrue(item.getChecked() == PullPushCheckboxTableViewer.getCheckState(info));
}
 

protected void controlChanged( Widget widget )
{

	ControlData data = (ControlData) widget.getData( );
	String newValue = null;
	if ( widget instanceof Button )
	{
		if ( ( ( (Button) widget ).getStyle( ) & SWT.RADIO ) != 0 )
		{
			RadioComposite parent = (RadioComposite) ( (Button) widget ).getParent( );
			data = (ControlData) parent.getData( );
			newValue = data.getValue( parent.getBtnIndex( (Button) widget ) );
		}
		else
		{
			newValue = data.getValue( ( (Button) widget ).getSelection( ) );
		}

	}
	else if ( widget instanceof Combo )
	{
		newValue = data.getValue( ( (Combo) widget ).getSelectionIndex( ) );
	}
	else
	{
		return;
	}
	String oldValue = setValue( data.getKey( ), newValue );
	validateSettings( data.getKey( ), oldValue, newValue );
}
 

protected void stop(Widget widget) {
    if (widget == currWidget) {
        if (!currWidget.isDisposed()) {
            currWidget.removeDisposeListener(this);
        }
        currWidget = null;
        changeState(false);
    }
}