|
Added
Link Here
|
| 1 |
package org.eclipse.ui.examples.presentation.customtoolbar.widgets; |
| 2 |
|
| 3 |
import java.util.ArrayList; |
| 4 |
import java.util.HashMap; |
| 5 |
import java.util.Iterator; |
| 6 |
import java.util.List; |
| 7 |
import java.util.ListIterator; |
| 8 |
|
| 9 |
import org.eclipse.jface.action.ContributionManager; |
| 10 |
import org.eclipse.jface.action.IContributionItem; |
| 11 |
import org.eclipse.jface.action.ICoolBarManager; |
| 12 |
import org.eclipse.jface.action.IMenuManager; |
| 13 |
import org.eclipse.jface.action.IToolBarManager; |
| 14 |
import org.eclipse.jface.action.MenuManager; |
| 15 |
import org.eclipse.jface.action.Separator; |
| 16 |
import org.eclipse.jface.action.ToolBarContributionItem; |
| 17 |
import org.eclipse.jface.util.Assert; |
| 18 |
import org.eclipse.jface.util.Policy; |
| 19 |
import org.eclipse.swt.SWT; |
| 20 |
import org.eclipse.swt.widgets.Composite; |
| 21 |
import org.eclipse.swt.widgets.Control; |
| 22 |
import org.eclipse.swt.widgets.CoolBar; |
| 23 |
import org.eclipse.swt.widgets.Menu; |
| 24 |
|
| 25 |
public class SCoolBarManager extends ContributionManager implements ICoolBarManager { |
| 26 |
|
| 27 |
/** |
| 28 |
* A separator created by the end user. |
| 29 |
*/ |
| 30 |
public final static String USER_SEPARATOR = "UserSeparator"; //$NON-NLS-1$ |
| 31 |
|
| 32 |
/** |
| 33 |
* The original creation order of the contribution items. |
| 34 |
*/ |
| 35 |
private ArrayList cbItemsCreationOrder = new ArrayList(); |
| 36 |
|
| 37 |
/** |
| 38 |
* MenuManager for cool bar pop-up menu, or null if none. |
| 39 |
*/ |
| 40 |
private MenuManager contextMenuManager = null; |
| 41 |
|
| 42 |
/** |
| 43 |
* The cool bar control; <code>null</code> before creation and after |
| 44 |
* disposal. |
| 45 |
*/ |
| 46 |
private SCoolBar coolBar = null; |
| 47 |
|
| 48 |
/** |
| 49 |
* The cool bar items style; <code>SWT.NONE</code> by default. |
| 50 |
*/ |
| 51 |
private int itemStyle = SWT.NONE; |
| 52 |
|
| 53 |
/** |
| 54 |
* Creates a new cool bar manager with the default style. Equivalent to |
| 55 |
* <code>CoolBarManager(SWT.NONE)</code>. |
| 56 |
*/ |
| 57 |
public SCoolBarManager() { |
| 58 |
// do nothing |
| 59 |
} |
| 60 |
|
| 61 |
/** |
| 62 |
* Creates a cool bar manager for an existing cool bar control. This |
| 63 |
* manager becomes responsible for the control, and will dispose of it when |
| 64 |
* the manager is disposed. |
| 65 |
* |
| 66 |
* @param coolBar |
| 67 |
* the cool bar control |
| 68 |
*/ |
| 69 |
public SCoolBarManager(SCoolBar coolBar) { |
| 70 |
this(); |
| 71 |
Assert.isNotNull(coolBar); |
| 72 |
this.coolBar = coolBar; |
| 73 |
itemStyle = coolBar.getStyle(); |
| 74 |
} |
| 75 |
|
| 76 |
/** |
| 77 |
* Creates a cool bar manager with the given SWT style. Calling <code>createControl</code> |
| 78 |
* will create the cool bar control. |
| 79 |
* |
| 80 |
* @param style |
| 81 |
* the cool bar item style; see |
| 82 |
* {@link org.eclipse.swt.widgets.CoolBar CoolBar}for for valid |
| 83 |
* style bits |
| 84 |
*/ |
| 85 |
public SCoolBarManager(int style) { |
| 86 |
itemStyle = style; |
| 87 |
} |
| 88 |
|
| 89 |
/* |
| 90 |
* (non-Javadoc) |
| 91 |
* |
| 92 |
* @see org.eclipse.jface.action.ICoolBarManager#add(org.eclipse.jface.action.IToolBarManager) |
| 93 |
*/ |
| 94 |
public void add(IToolBarManager toolBarManager) { |
| 95 |
Assert.isNotNull(toolBarManager); |
| 96 |
SToolBarContributionItem2 toolBarContributionItem = new SToolBarContributionItem2(toolBarManager); |
| 97 |
super.add(toolBarContributionItem); |
| 98 |
} |
| 99 |
|
| 100 |
public void add(IContributionItem item) { |
| 101 |
super.add(item); |
| 102 |
} |
| 103 |
|
| 104 |
/** |
| 105 |
* Collapses consecutive separators and removes a separator from the |
| 106 |
* beginning and end of the list. |
| 107 |
* |
| 108 |
* @param contributionList |
| 109 |
* the list of contributions; must not be <code>null</code>. |
| 110 |
* @return The contribution list provided with extraneous separators |
| 111 |
* removed; this value is never <code>null</code>, but may be |
| 112 |
* empty. |
| 113 |
*/ |
| 114 |
private ArrayList adjustContributionList(ArrayList contributionList) { |
| 115 |
IContributionItem item; |
| 116 |
// Fist remove a separator if it is the first element of the list |
| 117 |
if (contributionList.size() != 0) { |
| 118 |
item = (IContributionItem) contributionList.get(0); |
| 119 |
if (item.isSeparator()) { |
| 120 |
contributionList.remove(0); |
| 121 |
} |
| 122 |
|
| 123 |
ListIterator iterator = contributionList.listIterator(); |
| 124 |
// collapse consecutive separators |
| 125 |
while (iterator.hasNext()) { |
| 126 |
item = (IContributionItem) iterator.next(); |
| 127 |
if (item.isSeparator()) { |
| 128 |
while (iterator.hasNext()) { |
| 129 |
item = (IContributionItem) iterator.next(); |
| 130 |
if (item.isSeparator()) { |
| 131 |
iterator.remove(); |
| 132 |
} else { |
| 133 |
break; |
| 134 |
} |
| 135 |
} |
| 136 |
|
| 137 |
} |
| 138 |
} |
| 139 |
// Now check last element to see if there is a separator |
| 140 |
item = (IContributionItem) contributionList.get(contributionList |
| 141 |
.size() - 1); |
| 142 |
if (item.isSeparator()) { |
| 143 |
contributionList.remove(contributionList.size() - 1); |
| 144 |
} |
| 145 |
} |
| 146 |
return contributionList; |
| 147 |
|
| 148 |
} |
| 149 |
|
| 150 |
/* (non-Javadoc) |
| 151 |
* @see org.eclipse.jface.action.ContributionManager#checkDuplication(org.eclipse.jface.action.IContributionItem) |
| 152 |
*/ |
| 153 |
protected boolean allowItem(IContributionItem itemToAdd) { |
| 154 |
/* We will allow as many null entries as they like, though there should |
| 155 |
* be none. |
| 156 |
*/ |
| 157 |
if (itemToAdd == null) { |
| 158 |
return true; |
| 159 |
} |
| 160 |
|
| 161 |
/* Null identifiers can be expected in generic contribution items. |
| 162 |
*/ |
| 163 |
String firstId = itemToAdd.getId(); |
| 164 |
if (firstId == null) { |
| 165 |
return true; |
| 166 |
} |
| 167 |
|
| 168 |
// Cycle through the current list looking for duplicates. |
| 169 |
IContributionItem[] currentItems = getItems(); |
| 170 |
for (int i = 0; i < currentItems.length; i++) { |
| 171 |
IContributionItem currentItem = currentItems[i]; |
| 172 |
|
| 173 |
// We ignore null entries. |
| 174 |
if (currentItem == null) { |
| 175 |
continue; |
| 176 |
} |
| 177 |
|
| 178 |
String secondId = currentItem.getId(); |
| 179 |
if (firstId.equals(secondId)) { |
| 180 |
if (Policy.TRACE_TOOLBAR) { //$NON-NLS-1$ |
| 181 |
System.out.println("Trying to add a duplicate item."); //$NON-NLS-1$ |
| 182 |
new Exception().printStackTrace(System.out); |
| 183 |
System.out.println("DONE --------------------------"); //$NON-NLS-1$ |
| 184 |
} |
| 185 |
return false; |
| 186 |
} |
| 187 |
} |
| 188 |
|
| 189 |
return true; |
| 190 |
} |
| 191 |
|
| 192 |
/** |
| 193 |
* Positions the list iterator to the end of all the separators. Calling |
| 194 |
* <code>next()</code> the iterator should return the immediate object |
| 195 |
* following the last separator. |
| 196 |
* |
| 197 |
* @param iterator |
| 198 |
* the list iterator. |
| 199 |
*/ |
| 200 |
private void collapseSeparators(ListIterator iterator) { |
| 201 |
|
| 202 |
while (iterator.hasNext()) { |
| 203 |
IContributionItem item = (IContributionItem) iterator.next(); |
| 204 |
if (!item.isSeparator()) { |
| 205 |
iterator.previous(); |
| 206 |
return; |
| 207 |
} |
| 208 |
} |
| 209 |
} |
| 210 |
|
| 211 |
/** |
| 212 |
* Returns whether the cool bar control has been created and not yet |
| 213 |
* disposed. |
| 214 |
* |
| 215 |
* @return <code>true</code> if the control has been created and not yet |
| 216 |
* disposed, <code>false</code> otherwise |
| 217 |
*/ |
| 218 |
private boolean coolBarExist() { |
| 219 |
return coolBar != null && !coolBar.isDisposed(); |
| 220 |
} |
| 221 |
|
| 222 |
/** |
| 223 |
* Creates and returns this manager's cool bar control. Does not create a |
| 224 |
* new control if one already exists. |
| 225 |
* |
| 226 |
* @param parent |
| 227 |
* the parent control |
| 228 |
* @return the cool bar control |
| 229 |
*/ |
| 230 |
public Control createControl2(Composite parent) { |
| 231 |
Assert.isNotNull(parent); |
| 232 |
if (!coolBarExist()) { |
| 233 |
coolBar = new SCoolBar(parent, itemStyle); |
| 234 |
((SCoolBar)coolBar).setSkin(new HannoverGlobalCoolBarSkin()); |
| 235 |
coolBar.setMenu(getContextMenuControl()); |
| 236 |
coolBar.setLocked(false); |
| 237 |
coolBar.setSkin(new HannoverGlobalCoolBarSkin()); |
| 238 |
update(false); |
| 239 |
} |
| 240 |
return coolBar; |
| 241 |
} |
| 242 |
|
| 243 |
/** |
| 244 |
* Disposes of this cool bar manager and frees all allocated SWT resources. |
| 245 |
* Notifies all contribution items of the dispose. Note that this method |
| 246 |
* does not clean up references between this cool bar manager and its |
| 247 |
* associated contribution items. Use <code>removeAll</code> for that |
| 248 |
* purpose. |
| 249 |
*/ |
| 250 |
public void dispose() { |
| 251 |
if (coolBarExist()) { |
| 252 |
IContributionItem[] items = getItems(); |
| 253 |
for (int i = 0; i < items.length; i++) { |
| 254 |
// Disposes of the contribution item. |
| 255 |
// If Contribution Item is a toolbar then it will dispose of |
| 256 |
// all the nested |
| 257 |
// contribution items. |
| 258 |
items[i].dispose(); |
| 259 |
} |
| 260 |
coolBar.dispose(); |
| 261 |
coolBar = null; |
| 262 |
} |
| 263 |
// If a context menu existed then dispose of it. |
| 264 |
if (contextMenuManager != null) { |
| 265 |
contextMenuManager.dispose(); |
| 266 |
contextMenuManager = null; |
| 267 |
} |
| 268 |
|
| 269 |
} |
| 270 |
|
| 271 |
/** |
| 272 |
* Disposes the given cool item. |
| 273 |
* |
| 274 |
* @param item |
| 275 |
* the cool item to dispose |
| 276 |
*/ |
| 277 |
private void dispose(SCoolItem item) { |
| 278 |
if ((item != null) && !item.isDisposed()) { |
| 279 |
|
| 280 |
item.setData(null); |
| 281 |
Control control = item.getControl(); |
| 282 |
// if the control is already disposed, setting the coolitem |
| 283 |
// control to null will cause an SWT exception, workaround |
| 284 |
// for 19630 |
| 285 |
if ((control != null) && !control.isDisposed()) { |
| 286 |
item.setControl(null); |
| 287 |
} |
| 288 |
item.dispose(); |
| 289 |
} |
| 290 |
} |
| 291 |
|
| 292 |
/** |
| 293 |
* Finds the cool item associated with the given contribution item. |
| 294 |
* |
| 295 |
* @param item |
| 296 |
* the contribution item |
| 297 |
* @return the associated cool item, or <code>null</code> if not found |
| 298 |
*/ |
| 299 |
private SCoolItem findCoolItem(IContributionItem item) { |
| 300 |
if (coolBar == null) |
| 301 |
return null; |
| 302 |
SCoolItem[] items = coolBar.getItems(); |
| 303 |
for (int i = 0; i < items.length; i++) { |
| 304 |
SCoolItem coolItem = items[i]; |
| 305 |
IContributionItem data = (IContributionItem) coolItem.getData(); |
| 306 |
if (data != null && data.equals(item)) |
| 307 |
return coolItem; |
| 308 |
} |
| 309 |
return null; |
| 310 |
} |
| 311 |
|
| 312 |
/** |
| 313 |
* Return a consistent set of wrap indices. The return value will always |
| 314 |
* include at least one entry and the first entry will always be zero. |
| 315 |
* CoolBar.getWrapIndices() is inconsistent in whether or not it returns an |
| 316 |
* index for the first row. |
| 317 |
* |
| 318 |
* @param wraps |
| 319 |
* the wrap indicies from the cool bar widget |
| 320 |
* @return the adjusted wrap indicies. |
| 321 |
*/ |
| 322 |
private int[] getAdjustedWrapIndices(int[] wraps) { |
| 323 |
int[] adjustedWrapIndices; |
| 324 |
if (wraps.length == 0) { |
| 325 |
adjustedWrapIndices = new int[] { 0 }; |
| 326 |
} else { |
| 327 |
if (wraps[0] != 0) { |
| 328 |
adjustedWrapIndices = new int[wraps.length + 1]; |
| 329 |
adjustedWrapIndices[0] = 0; |
| 330 |
for (int i = 0; i < wraps.length; i++) { |
| 331 |
adjustedWrapIndices[i + 1] = wraps[i]; |
| 332 |
} |
| 333 |
} else { |
| 334 |
adjustedWrapIndices = wraps; |
| 335 |
} |
| 336 |
} |
| 337 |
return adjustedWrapIndices; |
| 338 |
} |
| 339 |
|
| 340 |
/** |
| 341 |
* Returns the control of the Menu Manager. If the menu manager does not |
| 342 |
* have a control then one is created. |
| 343 |
* |
| 344 |
* @return menu control associated with manager, or null if none |
| 345 |
*/ |
| 346 |
private Menu getContextMenuControl() { |
| 347 |
if ((contextMenuManager != null) && (coolBar != null)) { |
| 348 |
Menu menuWidget = contextMenuManager.getMenu(); |
| 349 |
if ((menuWidget == null) || (menuWidget.isDisposed())) { |
| 350 |
menuWidget = contextMenuManager.createContextMenu(coolBar); |
| 351 |
} |
| 352 |
return menuWidget; |
| 353 |
} |
| 354 |
return null; |
| 355 |
} |
| 356 |
|
| 357 |
/* |
| 358 |
* (non-Javadoc) |
| 359 |
* |
| 360 |
* @see org.eclipse.jface.action.ICoolBarManager#isLayoutLocked() |
| 361 |
*/ |
| 362 |
public IMenuManager getContextMenuManager() { |
| 363 |
return contextMenuManager; |
| 364 |
} |
| 365 |
|
| 366 |
/** |
| 367 |
* Returns the cool bar control for this manager. |
| 368 |
* |
| 369 |
* @return the cool bar control, or <code>null</code> if none |
| 370 |
*/ |
| 371 |
public CoolBar getControl() { |
| 372 |
return null; |
| 373 |
} |
| 374 |
|
| 375 |
/** |
| 376 |
* Returns an array list of all the contribution items in the manager. |
| 377 |
* |
| 378 |
* @return an array list of contribution items. |
| 379 |
*/ |
| 380 |
private ArrayList getItemList() { |
| 381 |
IContributionItem[] cbItems = getItems(); |
| 382 |
ArrayList list = new ArrayList(cbItems.length); |
| 383 |
for (int i = 0; i < cbItems.length; i++) { |
| 384 |
list.add(cbItems[i]); |
| 385 |
} |
| 386 |
return list; |
| 387 |
} |
| 388 |
|
| 389 |
/* |
| 390 |
* (non-Javadoc) |
| 391 |
* |
| 392 |
* @see org.eclipse.jface.action.ICoolBarManager#isLayoutLocked() |
| 393 |
*/ |
| 394 |
public boolean getLockLayout() { |
| 395 |
if (!coolBarExist()) { |
| 396 |
return false; |
| 397 |
} |
| 398 |
return coolBar.getLocked(); |
| 399 |
} |
| 400 |
|
| 401 |
/** |
| 402 |
* Returns the number of rows that should be displayed visually. |
| 403 |
* |
| 404 |
* @param items |
| 405 |
* the array of contributin items |
| 406 |
* @return the number of rows |
| 407 |
*/ |
| 408 |
private int getNumRows(IContributionItem[] items) { |
| 409 |
int numRows = 1; |
| 410 |
boolean separatorFound = false; |
| 411 |
for (int i = 0; i < items.length; i++) { |
| 412 |
if (items[i].isSeparator()) { |
| 413 |
separatorFound = true; |
| 414 |
} |
| 415 |
if ((separatorFound) && (items[i].isVisible()) |
| 416 |
&& (!items[i].isGroupMarker()) && (!items[i].isSeparator())) { |
| 417 |
numRows++; |
| 418 |
separatorFound = false; |
| 419 |
} |
| 420 |
} |
| 421 |
return numRows; |
| 422 |
} |
| 423 |
|
| 424 |
/* |
| 425 |
* (non-Javadoc) |
| 426 |
* |
| 427 |
* @see org.eclipse.jface.action.ICoolBarManager#getStyle() |
| 428 |
*/ |
| 429 |
public int getStyle() { |
| 430 |
return itemStyle; |
| 431 |
} |
| 432 |
|
| 433 |
/** |
| 434 |
* Subclasses may extend this <code>ContributionManager</code> method, |
| 435 |
* but must call <code>super.itemAdded</code>. |
| 436 |
* |
| 437 |
* @see org.eclipse.jface.action.ContributionManager#itemAdded(org.eclipse.jface.action.IContributionItem) |
| 438 |
*/ |
| 439 |
protected void itemAdded(IContributionItem item) { |
| 440 |
Assert.isNotNull(item); |
| 441 |
super.itemAdded(item); |
| 442 |
int insertedAt = indexOf(item); |
| 443 |
boolean replaced = false; |
| 444 |
final int size = cbItemsCreationOrder.size(); |
| 445 |
for (int i = 0; i < size; i++) { |
| 446 |
IContributionItem created = (IContributionItem) cbItemsCreationOrder |
| 447 |
.get(i); |
| 448 |
if (created.getId() != null && created.getId().equals(item.getId())) { |
| 449 |
cbItemsCreationOrder.set(i, item); |
| 450 |
replaced = true; |
| 451 |
break; |
| 452 |
} |
| 453 |
} |
| 454 |
|
| 455 |
if (!replaced) { |
| 456 |
cbItemsCreationOrder.add(Math.min(Math.max(insertedAt, 0), |
| 457 |
cbItemsCreationOrder.size()), item); |
| 458 |
} |
| 459 |
} |
| 460 |
|
| 461 |
/** |
| 462 |
* Subclasses may extend this <code>ContributionManager</code> method, |
| 463 |
* but must call <code>super.itemRemoved</code>. |
| 464 |
* |
| 465 |
* @see org.eclipse.jface.action.ContributionManager#itemRemoved(org.eclipse.jface.action.IContributionItem) |
| 466 |
*/ |
| 467 |
protected void itemRemoved(IContributionItem item) { |
| 468 |
Assert.isNotNull(item); |
| 469 |
super.itemRemoved(item); |
| 470 |
SCoolItem coolItem = findCoolItem(item); |
| 471 |
if (coolItem != null) { |
| 472 |
coolItem.setData(null); |
| 473 |
} |
| 474 |
} |
| 475 |
|
| 476 |
/** |
| 477 |
* Positions the list iterator to the starting of the next row. By calling |
| 478 |
* next on the returned iterator, it will return the first element of the |
| 479 |
* next row. |
| 480 |
* |
| 481 |
* @param iterator |
| 482 |
* the list iterator of contribution items |
| 483 |
* @param ignoreCurrentItem |
| 484 |
* Whether the current item in the iterator should be considered |
| 485 |
* (as well as subsequent items). |
| 486 |
*/ |
| 487 |
private void nextRow(ListIterator iterator, boolean ignoreCurrentItem) { |
| 488 |
|
| 489 |
IContributionItem currentElement = null; |
| 490 |
if (!ignoreCurrentItem && iterator.hasPrevious()) { |
| 491 |
currentElement = (IContributionItem) iterator.previous(); |
| 492 |
iterator.next(); |
| 493 |
} |
| 494 |
|
| 495 |
if ((currentElement != null) && (currentElement.isSeparator())) { |
| 496 |
collapseSeparators(iterator); |
| 497 |
return; |
| 498 |
} else { |
| 499 |
//Find next separator |
| 500 |
while (iterator.hasNext()) { |
| 501 |
IContributionItem item = (IContributionItem) iterator.next(); |
| 502 |
if (item.isSeparator()) { |
| 503 |
// we we find a separator, collapse any consecutive |
| 504 |
// separators |
| 505 |
// and return |
| 506 |
collapseSeparators(iterator); |
| 507 |
return; |
| 508 |
} |
| 509 |
} |
| 510 |
} |
| 511 |
} |
| 512 |
|
| 513 |
/* |
| 514 |
* Used for debuging. Prints all the items in the internal structures. |
| 515 |
*/ |
| 516 |
// private void printContributions(ArrayList contributionList) { |
| 517 |
// int index = 0; |
| 518 |
// System.out.println("----------------------------------\n"); //$NON-NLS-1$ |
| 519 |
// for (Iterator i = contributionList.iterator(); i.hasNext(); index++) { |
| 520 |
// IContributionItem item = (IContributionItem) i.next(); |
| 521 |
// if (item.isSeparator()) { |
| 522 |
// System.out.println("Separator"); //$NON-NLS-1$ |
| 523 |
// } else { |
| 524 |
// System.out.println(index + ". Item id: " + item.getId() //$NON-NLS-1$ |
| 525 |
// + " - is Visible: " //$NON-NLS-1$ |
| 526 |
// + item.isVisible()); |
| 527 |
// } |
| 528 |
// } |
| 529 |
// } |
| 530 |
/** |
| 531 |
* Synchronizes the visual order of the cool items in the control with this |
| 532 |
* manager's internal data structures. This method should be called before |
| 533 |
* requesting the order of the contribution items to ensure that the order |
| 534 |
* is accurate. |
| 535 |
* <p> |
| 536 |
* Note that <code>update()</code> and <code>refresh()</code> are |
| 537 |
* converses: <code>update()</code> changes the visual order to match the |
| 538 |
* internal structures, and <code>refresh</code> changes the internal |
| 539 |
* structures to match the visual order. |
| 540 |
* </p> |
| 541 |
*/ |
| 542 |
public void refresh() { |
| 543 |
if (!coolBarExist()) { |
| 544 |
return; |
| 545 |
} |
| 546 |
|
| 547 |
// Retreives the list of contribution items as an array list |
| 548 |
ArrayList contributionList = getItemList(); |
| 549 |
|
| 550 |
// Check the size of the list |
| 551 |
if (contributionList.size() == 0) |
| 552 |
return; |
| 553 |
|
| 554 |
// The list of all the cool items in their visual order |
| 555 |
SCoolItem[] coolItems = coolBar.getItems(); |
| 556 |
// The wrap indicies of the coolbar |
| 557 |
int[] wrapIndicies = getAdjustedWrapIndices(coolBar.getWrapIndices()); |
| 558 |
|
| 559 |
int row = 0; |
| 560 |
int coolItemIndex = 0; |
| 561 |
|
| 562 |
// Traverse through all cool items in the coolbar add them to a new |
| 563 |
// data structure |
| 564 |
// in the correct order |
| 565 |
ArrayList displayedItems = new ArrayList(coolBar.getItemCount()); |
| 566 |
for (int i = 0; i < coolItems.length; i++) { |
| 567 |
SCoolItem coolItem = coolItems[i]; |
| 568 |
if (coolItem.getData() instanceof IContributionItem) { |
| 569 |
IContributionItem cbItem = (IContributionItem) coolItem |
| 570 |
.getData(); |
| 571 |
displayedItems.add(Math.min(i, displayedItems.size()), cbItem); |
| 572 |
} |
| 573 |
} |
| 574 |
|
| 575 |
// Add separators to the displayed Items data structure |
| 576 |
int offset = 0; |
| 577 |
for (int i = 1; i < wrapIndicies.length; i++) { |
| 578 |
int insertAt = wrapIndicies[i] + offset; |
| 579 |
displayedItems.add(insertAt, new Separator(USER_SEPARATOR)); |
| 580 |
offset++; |
| 581 |
} |
| 582 |
|
| 583 |
// Determine which rows are invisible |
| 584 |
ArrayList existingVisibleRows = new ArrayList(4); |
| 585 |
ListIterator rowIterator = contributionList.listIterator(); |
| 586 |
collapseSeparators(rowIterator); |
| 587 |
int numRow = 0; |
| 588 |
while (rowIterator.hasNext()) { |
| 589 |
// Scan row |
| 590 |
while (rowIterator.hasNext()) { |
| 591 |
IContributionItem cbItem = (IContributionItem) rowIterator |
| 592 |
.next(); |
| 593 |
if (displayedItems.contains(cbItem)) { |
| 594 |
existingVisibleRows.add(new Integer(numRow)); |
| 595 |
break; |
| 596 |
} |
| 597 |
if (cbItem.isSeparator()) { |
| 598 |
break; |
| 599 |
} |
| 600 |
} |
| 601 |
nextRow(rowIterator, false); |
| 602 |
numRow++; |
| 603 |
} |
| 604 |
|
| 605 |
Iterator existingRows = existingVisibleRows.iterator(); |
| 606 |
// Adjust row number to the first visible |
| 607 |
if (existingRows.hasNext()) { |
| 608 |
row = ((Integer) existingRows.next()).intValue(); |
| 609 |
} |
| 610 |
|
| 611 |
HashMap itemLocation = new HashMap(); |
| 612 |
for (ListIterator locationIterator = displayedItems.listIterator(); locationIterator |
| 613 |
.hasNext();) { |
| 614 |
IContributionItem item = (IContributionItem) locationIterator |
| 615 |
.next(); |
| 616 |
if (item.isSeparator()) { |
| 617 |
if (existingRows.hasNext()) { |
| 618 |
Integer value = (Integer) existingRows.next(); |
| 619 |
row = value.intValue(); |
| 620 |
} else { |
| 621 |
row++; |
| 622 |
} |
| 623 |
} else { |
| 624 |
itemLocation.put(item, new Integer(row)); |
| 625 |
} |
| 626 |
|
| 627 |
} |
| 628 |
|
| 629 |
// Insert the contribution items in their correct location |
| 630 |
for (ListIterator iterator = displayedItems.listIterator(); iterator |
| 631 |
.hasNext();) { |
| 632 |
IContributionItem cbItem = (IContributionItem) iterator.next(); |
| 633 |
if (cbItem.isSeparator()) { |
| 634 |
coolItemIndex = 0; |
| 635 |
} else { |
| 636 |
relocate(cbItem, coolItemIndex, contributionList, itemLocation); |
| 637 |
cbItem.saveWidgetState(); |
| 638 |
coolItemIndex++; |
| 639 |
} |
| 640 |
} |
| 641 |
|
| 642 |
if (contributionList.size() != 0) { |
| 643 |
contributionList = adjustContributionList(contributionList); |
| 644 |
IContributionItem[] array = new IContributionItem[contributionList |
| 645 |
.size() - 1]; |
| 646 |
array = (IContributionItem[]) contributionList.toArray(array); |
| 647 |
internalSetItems(array); |
| 648 |
} |
| 649 |
|
| 650 |
} |
| 651 |
|
| 652 |
/** |
| 653 |
* Relocates the given contribution item to the specified index. |
| 654 |
* |
| 655 |
* @param cbItem |
| 656 |
* the conribution item to relocate |
| 657 |
* @param index |
| 658 |
* the index to locate this item |
| 659 |
* @param contributionList |
| 660 |
* the current list of conrtributions |
| 661 |
* @param itemLocation |
| 662 |
*/ |
| 663 |
private void relocate(IContributionItem cbItem, int index, |
| 664 |
ArrayList contributionList, HashMap itemLocation) { |
| 665 |
|
| 666 |
if (!(itemLocation.get(cbItem) instanceof Integer)) |
| 667 |
return; |
| 668 |
int targetRow = ((Integer) itemLocation.get(cbItem)).intValue(); |
| 669 |
|
| 670 |
int cbInternalIndex = contributionList.indexOf(cbItem); |
| 671 |
|
| 672 |
// by default add to end of list |
| 673 |
int insertAt = contributionList.size(); |
| 674 |
// Find the row to place this item in. |
| 675 |
ListIterator iterator = contributionList.listIterator(); |
| 676 |
// bypass any separators at the begining |
| 677 |
collapseSeparators(iterator); |
| 678 |
int currentRow = -1; |
| 679 |
while (iterator.hasNext()) { |
| 680 |
|
| 681 |
currentRow++; |
| 682 |
if (currentRow == targetRow) { |
| 683 |
// We found the row to insert the item |
| 684 |
int virtualIndex = 0; |
| 685 |
insertAt = iterator.nextIndex(); |
| 686 |
// first check the position of the current element (item) |
| 687 |
// then get the next element |
| 688 |
while (iterator.hasNext()) { |
| 689 |
IContributionItem item = (IContributionItem) iterator |
| 690 |
.next(); |
| 691 |
Integer itemRow = (Integer) itemLocation.get(item); |
| 692 |
if (item.isSeparator()) |
| 693 |
break; |
| 694 |
// if the item has an associate widget |
| 695 |
if ((itemRow != null) && (itemRow.intValue() == targetRow)) { |
| 696 |
// if the next element is the index we are looking for |
| 697 |
// then break |
| 698 |
if (virtualIndex >= index) |
| 699 |
break; |
| 700 |
virtualIndex++; |
| 701 |
|
| 702 |
} |
| 703 |
insertAt++; |
| 704 |
} |
| 705 |
// If we don't need to move it then we return |
| 706 |
if (cbInternalIndex == insertAt) |
| 707 |
return; |
| 708 |
break; |
| 709 |
} |
| 710 |
nextRow(iterator, true); |
| 711 |
} |
| 712 |
contributionList.remove(cbItem); |
| 713 |
|
| 714 |
// Adjust insertAt index |
| 715 |
if (cbInternalIndex < insertAt) { |
| 716 |
insertAt--; |
| 717 |
} |
| 718 |
|
| 719 |
// if we didn't find the row then add a new row |
| 720 |
if (currentRow != targetRow) { |
| 721 |
contributionList.add(new Separator(USER_SEPARATOR)); |
| 722 |
insertAt = contributionList.size(); |
| 723 |
} |
| 724 |
insertAt = Math.min(insertAt, contributionList.size()); |
| 725 |
contributionList.add(insertAt, cbItem); |
| 726 |
|
| 727 |
} |
| 728 |
|
| 729 |
/** |
| 730 |
* Restores the canonical order of this cool bar manager. The canonical |
| 731 |
* order is the order in which the contribution items where added. |
| 732 |
*/ |
| 733 |
public void resetItemOrder() { |
| 734 |
for (ListIterator iterator = cbItemsCreationOrder.listIterator(); iterator |
| 735 |
.hasNext();) { |
| 736 |
IContributionItem item = (IContributionItem) iterator.next(); |
| 737 |
// if its a user separator then do not include in original order. |
| 738 |
if ((item.getId() != null) && (item.getId().equals(USER_SEPARATOR))) { |
| 739 |
iterator.remove(); |
| 740 |
} |
| 741 |
} |
| 742 |
IContributionItem[] itemsToSet = new IContributionItem[cbItemsCreationOrder |
| 743 |
.size()]; |
| 744 |
cbItemsCreationOrder.toArray(itemsToSet); |
| 745 |
setItems(itemsToSet); |
| 746 |
} |
| 747 |
|
| 748 |
/* |
| 749 |
* (non-Javadoc) |
| 750 |
* |
| 751 |
* @see org.eclipse.jface.action.ICoolBarManager#setContextMenuManager(org.eclipse.jface.action.IMenuManager) |
| 752 |
*/ |
| 753 |
public void setContextMenuManager(IMenuManager contextMenuManager) { |
| 754 |
this.contextMenuManager = (MenuManager) contextMenuManager; |
| 755 |
if (coolBar != null) { |
| 756 |
coolBar.setMenu(getContextMenuControl()); |
| 757 |
} |
| 758 |
} |
| 759 |
|
| 760 |
/** |
| 761 |
* Replaces the current items with the given items. |
| 762 |
* Forces an update. |
| 763 |
* |
| 764 |
* @param newItems the items with which to replace the current items |
| 765 |
*/ |
| 766 |
public void setItems(IContributionItem[] newItems) { |
| 767 |
// dispose of all the cool items on the cool bar manager |
| 768 |
/* FIXME TFS |
| 769 |
* This is disposing of the coolItems but references are still hanging around. Might |
| 770 |
* be a problem with SCoolBar and or SCoolItem. [Terry Smith 12/9/2005] |
| 771 |
* |
| 772 |
if (coolBar != null) { |
| 773 |
SCoolItem[] coolItems = coolBar.getItems(); |
| 774 |
for (int i = 0; i < coolItems.length; i++) { |
| 775 |
dispose(coolItems[i]); |
| 776 |
} |
| 777 |
} |
| 778 |
// Set the internal structure to this order |
| 779 |
internalSetItems(newItems); |
| 780 |
*/ |
| 781 |
// Force and update |
| 782 |
update(true); |
| 783 |
} |
| 784 |
|
| 785 |
/* |
| 786 |
* (non-Javadoc) |
| 787 |
* |
| 788 |
* @see org.eclipse.jface.action.ICoolBarManager#lockLayout(boolean) |
| 789 |
*/ |
| 790 |
public void setLockLayout(boolean value) { |
| 791 |
if (!coolBarExist()) { |
| 792 |
return; |
| 793 |
} |
| 794 |
coolBar.setLocked(value); |
| 795 |
} |
| 796 |
|
| 797 |
/** |
| 798 |
* Subclasses may extend this <code>IContributionManager</code> method, |
| 799 |
* but must call <code>super.update</code>. |
| 800 |
* |
| 801 |
* @see org.eclipse.jface.action.IContributionManager#update(boolean) |
| 802 |
*/ |
| 803 |
public void update(boolean force) { |
| 804 |
if ((!isDirty() && !force) || (!coolBarExist())) { |
| 805 |
return; |
| 806 |
} |
| 807 |
|
| 808 |
boolean relock = false; |
| 809 |
boolean changed = false; |
| 810 |
|
| 811 |
try { |
| 812 |
coolBar.setRedraw(false); |
| 813 |
|
| 814 |
// Refresh the widget data with the internal data structure. |
| 815 |
refresh(); |
| 816 |
|
| 817 |
if (coolBar.getLocked()) { |
| 818 |
coolBar.setLocked(false); |
| 819 |
relock = true; |
| 820 |
} |
| 821 |
|
| 822 |
/* |
| 823 |
* Make a list of items including only those items that are |
| 824 |
* visible. Separators should stay because they mark line breaks in |
| 825 |
* a cool bar. |
| 826 |
*/ |
| 827 |
final IContributionItem[] items = getItems(); |
| 828 |
final List visibleItems = new ArrayList(items.length); |
| 829 |
for (int i = 0; i < items.length; i++) { |
| 830 |
final IContributionItem item = items[i]; |
| 831 |
if (item.isVisible()) { |
| 832 |
visibleItems.add(item); |
| 833 |
} |
| 834 |
} |
| 835 |
|
| 836 |
/* |
| 837 |
* Make a list of CoolItem widgets in the cool bar for which there |
| 838 |
* is no current visible contribution item. These are the widgets |
| 839 |
* to be disposed. Dynamic items are also removed. |
| 840 |
*/ |
| 841 |
SCoolItem[] coolItems = coolBar.getItems(); |
| 842 |
final ArrayList coolItemsToRemove = new ArrayList(coolItems.length); |
| 843 |
for (int i = 0; i < coolItems.length; i++) { |
| 844 |
final Object data = coolItems[i].getData(); |
| 845 |
if ((data == null) |
| 846 |
|| (!visibleItems.contains(data)) |
| 847 |
|| ((data instanceof IContributionItem) && ((IContributionItem) data) |
| 848 |
.isDynamic())) { |
| 849 |
coolItemsToRemove.add(coolItems[i]); |
| 850 |
} |
| 851 |
} |
| 852 |
|
| 853 |
// Dispose of any items in the list to be removed. |
| 854 |
for (int i = coolItemsToRemove.size() - 1; i >= 0; i--) { |
| 855 |
SCoolItem coolItem = (SCoolItem) coolItemsToRemove.get(i); |
| 856 |
if (!coolItem.isDisposed()) { |
| 857 |
Control control = coolItem.getControl(); |
| 858 |
if (control != null) { |
| 859 |
coolItem.setControl(null); |
| 860 |
control.dispose(); |
| 861 |
} |
| 862 |
coolItem.dispose(); |
| 863 |
} |
| 864 |
} |
| 865 |
|
| 866 |
// Add any new items by telling them to fill. |
| 867 |
coolItems = coolBar.getItems(); |
| 868 |
IContributionItem sourceItem; |
| 869 |
IContributionItem destinationItem; |
| 870 |
int sourceIndex = 0; |
| 871 |
int destinationIndex = 0; |
| 872 |
final Iterator visibleItemItr = visibleItems.iterator(); |
| 873 |
while (visibleItemItr.hasNext()) { |
| 874 |
sourceItem = (IContributionItem) visibleItemItr.next(); |
| 875 |
|
| 876 |
// Retrieve the corresponding contribution item from SWT's |
| 877 |
// data. |
| 878 |
if (sourceIndex < coolItems.length) { |
| 879 |
destinationItem = (IContributionItem) coolItems[sourceIndex] |
| 880 |
.getData(); |
| 881 |
} else { |
| 882 |
destinationItem = null; |
| 883 |
} |
| 884 |
|
| 885 |
// The items match is they are equal or both separators. |
| 886 |
if (destinationItem != null) { |
| 887 |
if (sourceItem.equals(destinationItem)) { |
| 888 |
sourceIndex++; |
| 889 |
destinationIndex++; |
| 890 |
sourceItem.update(); |
| 891 |
continue; |
| 892 |
|
| 893 |
} else if ((destinationItem.isSeparator()) |
| 894 |
&& (sourceItem.isSeparator())) { |
| 895 |
coolItems[sourceIndex].setData(sourceItem); |
| 896 |
sourceIndex++; |
| 897 |
destinationIndex++; |
| 898 |
sourceItem.update(); |
| 899 |
continue; |
| 900 |
|
| 901 |
} |
| 902 |
} |
| 903 |
|
| 904 |
// Otherwise, a new item has to be added. |
| 905 |
final int start = coolBar.getItemCount(); |
| 906 |
if (sourceItem instanceof ISContributionItem) |
| 907 |
((ISContributionItem)sourceItem).fill(coolBar, destinationIndex); |
| 908 |
final int newItems = coolBar.getItemCount() - start; |
| 909 |
for (int i = 0; i < newItems; i++) { |
| 910 |
coolBar.getItem(destinationIndex++).setData(sourceItem); |
| 911 |
} |
| 912 |
changed = true; |
| 913 |
} |
| 914 |
|
| 915 |
// Remove any old widgets not accounted for. |
| 916 |
for (int i = coolItems.length - 1; i >= sourceIndex; i--) { |
| 917 |
final SCoolItem item = coolItems[i]; |
| 918 |
if (!item.isDisposed()) { |
| 919 |
Control control = item.getControl(); |
| 920 |
if (control != null) { |
| 921 |
item.setControl(null); |
| 922 |
control.dispose(); |
| 923 |
} |
| 924 |
item.dispose(); |
| 925 |
changed = true; |
| 926 |
} |
| 927 |
} |
| 928 |
|
| 929 |
// Update wrap indices. |
| 930 |
updateWrapIndices(); |
| 931 |
|
| 932 |
// Update the sizes. |
| 933 |
for (int i = 0; i < items.length; i++) { |
| 934 |
IContributionItem item = items[i]; |
| 935 |
item.update(SIZE); |
| 936 |
} |
| 937 |
|
| 938 |
// if the coolBar was previously locked then lock it |
| 939 |
if (relock) { |
| 940 |
coolBar.setLocked(true); |
| 941 |
} |
| 942 |
|
| 943 |
if (changed) { |
| 944 |
updateTabOrder(); |
| 945 |
} |
| 946 |
|
| 947 |
// We are no longer dirty. |
| 948 |
setDirty(false); |
| 949 |
} finally { |
| 950 |
coolBar.setRedraw(true); |
| 951 |
} |
| 952 |
} |
| 953 |
|
| 954 |
/** |
| 955 |
* Sets the tab order of the coolbar to the visual order of its items. |
| 956 |
*/ |
| 957 |
/* package */void updateTabOrder() { |
| 958 |
if (coolBar != null) { |
| 959 |
SCoolItem[] items = coolBar.getItems(); |
| 960 |
if (items != null) { |
| 961 |
ArrayList children = new ArrayList(items.length); |
| 962 |
for (int i = 0; i < items.length; i++) { |
| 963 |
if ((items[i].getControl() != null) |
| 964 |
&& (!items[i].getControl().isDisposed())) { |
| 965 |
children.add(items[i].getControl()); |
| 966 |
} |
| 967 |
} |
| 968 |
// Convert array |
| 969 |
Control[] childrenArray = new Control[0]; |
| 970 |
childrenArray = (Control[]) children.toArray(childrenArray); |
| 971 |
|
| 972 |
if (childrenArray != null) { |
| 973 |
coolBar.setTabList(childrenArray); |
| 974 |
} |
| 975 |
|
| 976 |
} |
| 977 |
} |
| 978 |
} |
| 979 |
|
| 980 |
/** |
| 981 |
* Updates the indices at which the cool bar should wrap. |
| 982 |
*/ |
| 983 |
private void updateWrapIndices() { |
| 984 |
final IContributionItem[] items = getItems(); |
| 985 |
final int numRows = getNumRows(items) - 1; |
| 986 |
|
| 987 |
// Generate the list of wrap indices. |
| 988 |
final int[] wrapIndices = new int[numRows]; |
| 989 |
boolean foundSeparator = false; |
| 990 |
int j = 0; |
| 991 |
for (int i = 0; i < items.length; i++) { |
| 992 |
IContributionItem item = items[i]; |
| 993 |
SCoolItem coolItem = findCoolItem(item); |
| 994 |
if (item.isSeparator()) { |
| 995 |
foundSeparator = true; |
| 996 |
} |
| 997 |
if ((!item.isSeparator()) && (!item.isGroupMarker()) |
| 998 |
&& (item.isVisible()) && (coolItem != null) |
| 999 |
&& (foundSeparator)) { |
| 1000 |
wrapIndices[j] = coolBar.indexOf(coolItem); |
| 1001 |
j++; |
| 1002 |
foundSeparator = false; |
| 1003 |
} |
| 1004 |
} |
| 1005 |
|
| 1006 |
/* |
| 1007 |
* Check to see if these new wrap indices are different than the old |
| 1008 |
* ones. |
| 1009 |
*/ |
| 1010 |
final int[] oldIndices = coolBar.getWrapIndices(); |
| 1011 |
boolean shouldUpdate = false; |
| 1012 |
if (oldIndices.length == wrapIndices.length) { |
| 1013 |
for (int i = 0; i < oldIndices.length; i++) { |
| 1014 |
if (oldIndices[i] != wrapIndices[i]) { |
| 1015 |
shouldUpdate = true; |
| 1016 |
break; |
| 1017 |
} |
| 1018 |
} |
| 1019 |
} else { |
| 1020 |
shouldUpdate = true; |
| 1021 |
} |
| 1022 |
|
| 1023 |
if (shouldUpdate) { |
| 1024 |
coolBar.setWrapIndices(wrapIndices); |
| 1025 |
} |
| 1026 |
} |
| 1027 |
|
| 1028 |
public CoolBar createControl(Composite parent) { |
| 1029 |
return null; |
| 1030 |
} |
| 1031 |
|
| 1032 |
public Control getControl2() { |
| 1033 |
return coolBar; |
| 1034 |
} |
| 1035 |
} |
