The Trunk: Morphic-mt.1474.mcz

Marcel Taeumel uploaded a new version of Morphic to project The Trunk:
http://source.squeak.org/trunk/Morphic-mt.1474.mcz

==================== Summary ====================

Name: Morphic-mt.1474
Author: mt
Time: 9 January 2019, 9:00:34.991737 am
UUID: 14bd0540-84ba-480a-9878-754c07a26db5
Ancestors: Morphic-tpr.1473

Clean-up and bug fixes in resize grips. See http://forum.world.st/Please-Review-Some-updates-for-resize-grips-td5092584.html

=============== Diff against Morphic-tpr.1473 ===============

Item was changed:
+ (PackageInfo named: 'Morphic') preamble: '"Disable deprecation warnings to avoid hick-ups."
+ Deprecation showDeprecationWarnings: false.'!
- (PackageInfo named: 'Morphic') preamble: 'SimpleBorder allSubInstancesDo: [ :each |
- (each instVarNamed: #width) ifNil: [ each instVarNamed: #width put: 0 ].
- (each instVarNamed: #color) ifNil: [ each instVarNamed: #color put: Color transparent ].
- (each instVarNamed: #baseColor) ifNil: [ each instVarNamed: #baseColor put: Color transparent ] ].'!

Item was changed:
  Morph subclass: #AbstractResizerMorph
+ instanceVariableNames: 'handleColor handleInset lastMouse showHandle'
+ classVariableNames: 'GripThickness HandleLength'
- instanceVariableNames: 'dotColor handleColor lastMouse'
- classVariableNames: ''
  poolDictionaries: ''
  category: 'Morphic-Windows'!
 
  !AbstractResizerMorph commentStamp: 'jmv 1/29/2006 17:15' prior: 0!
  I am the superclass of a hierarchy of morph specialized in allowing the user to resize or rearrange windows and panes.!

Item was changed:
+ ----- Method: AbstractResizerMorph class>>gripThickness (in category 'preferences') -----
- ----- Method: AbstractResizerMorph class>>gripThickness (in category 'constants') -----
  gripThickness
  "A number in pixels that encodes the area were the user can target splitters or edge grips."
 
+ <preference: 'Grip Thickness'
+ category: 'windows'
+ description: 'A number in pixels that encodes the area were the user can target splitters or edge grips such as in application windows. Bigger grips make it easier to click on them.'
+ type: #Number>
+
+ ^ GripThickness ifNil: [4]!
- ^ 4!

Item was added:
+ ----- Method: AbstractResizerMorph class>>gripThickness: (in category 'preferences') -----
+ gripThickness: anInteger
+
+ GripThickness := anInteger.
+ Project current restoreDisplay.
+
+ self flag: #todo. "mt: Update existing grips. This is challenging because it interferes with ProportionalLayoutPolicy, which is tricky to refresh from here for arbitrary morphs."!

Item was added:
+ ----- Method: AbstractResizerMorph class>>handleLength (in category 'preferences') -----
+ handleLength
+
+ <preference: 'Handle Length'
+ category: 'windows'
+ description: 'AThe size of a grip handle if shown. Can be interpreted as width or height, depending of the resizer orientation. Does not affect the clickable area. See grip thickness for that.'
+ type: #Number>
+
+ ^ HandleLength ifNil: [25]!

Item was added:
+ ----- Method: AbstractResizerMorph class>>handleLength: (in category 'preferences') -----
+ handleLength: anInteger
+
+ HandleLength := anInteger.
+ Project current restoreDisplay.
+
+ self flag: #todo. "mt: Update existing grips. This is challenging because it interferes with ProportionalLayoutPolicy, which is tricky to refresh from here for arbitrary morphs."!

Item was removed:
- ----- Method: AbstractResizerMorph>>dotColor (in category 'as yet unclassified') -----
- dotColor
-
- ^ dotColor ifNil: [self setDefaultColors. dotColor]!

Item was changed:
  ----- Method: AbstractResizerMorph>>handleColor (in category 'accessing') -----
  handleColor
+ "Either use my handle color if set up or derive the handle color from my owner's color if I have an owner."
+
+ ^ (handleColor notNil or: [self owner isNil])
+ ifTrue: [handleColor ifNil: [Color black]]
+ ifFalse: [(self userInterfaceTheme resizerColorModifier ifNil: [ [:c | c muchDarker] ])
+ value: (self owner color isTransparent ifTrue: [Color white] ifFalse: [self owner color]) ]!
-
- ^ handleColor ifNil: [self setDefaultColors. handleColor]!

Item was added:
+ ----- Method: AbstractResizerMorph>>handleColor: (in category 'accessing') -----
+ handleColor: aColor
+
+ handleColor := aColor.
+ self changed.!

Item was added:
+ ----- Method: AbstractResizerMorph>>handleInset (in category 'accessing') -----
+ handleInset
+
+ ^ handleInset ifNil: [1]!

Item was added:
+ ----- Method: AbstractResizerMorph>>handleInset: (in category 'accessing') -----
+ handleInset: anInteger
+
+ handleInset := anInteger.
+ self changed.!

Item was removed:
- ----- Method: AbstractResizerMorph>>isCursorOverHandle (in category 'testing') -----
- isCursorOverHandle
-
- ^ true!

Item was changed:
  ----- Method: AbstractResizerMorph>>mouseDown: (in category 'event handling') -----
  mouseDown: anEvent
 
+ self referencePoint: anEvent position.!
- lastMouse := anEvent cursorPoint!

Item was changed:
  ----- Method: AbstractResizerMorph>>mouseEnter: (in category 'event handling') -----
  mouseEnter: anEvent
 
+ anEvent hand showTemporaryCursor: self resizeCursor.!
- self isCursorOverHandle ifTrue:
- [self setInverseColors.
- self changed.
- anEvent hand showTemporaryCursor: self resizeCursor]!

Item was changed:
  ----- Method: AbstractResizerMorph>>mouseLeave: (in category 'event handling') -----
  mouseLeave: anEvent
 
+ anEvent hand showTemporaryCursor: nil.!
- anEvent hand showTemporaryCursor: nil.
- self setDefaultColors.
- self changed!

Item was added:
+ ----- Method: AbstractResizerMorph>>referencePoint (in category 'accessing') -----
+ referencePoint
+
+ ^ lastMouse!

Item was changed:
  ----- Method: AbstractResizerMorph>>resizeCursor (in category 'accessing') -----
  resizeCursor
+ "The cursor shape I will set to the hand on hovering."
+
+ self subclassResponsibility.!
-
- self subclassResponsibility!

Item was changed:
+ ----- Method: AbstractResizerMorph>>setDefaultColors (in category 'initialization') -----
- ----- Method: AbstractResizerMorph>>setDefaultColors (in category 'private') -----
  setDefaultColors
 
+ "handleColor := Color lightGray lighter lighter.
+ dotColor := Color gray lighter"!
- handleColor := Color lightGray lighter lighter.
- dotColor := Color gray lighter!

Item was changed:
+ ----- Method: AbstractResizerMorph>>setInverseColors (in category 'initialization') -----
- ----- Method: AbstractResizerMorph>>setInverseColors (in category 'private') -----
  setInverseColors
 
+ "handleColor := Color lightGray.
+ dotColor := Color white"!
- handleColor := Color lightGray.
- dotColor := Color white!

Item was added:
+ ----- Method: AbstractResizerMorph>>showHandle (in category 'accessing') -----
+ showHandle
+
+ ^ showHandle ifNil: [false]!

Item was added:
+ ----- Method: AbstractResizerMorph>>showHandle: (in category 'accessing') -----
+ showHandle: aBoolean
+
+ showHandle := aBoolean.
+ self changed.!

Item was changed:
  ----- Method: BorderGripMorph>>drawOn: (in category 'drawing') -----
  drawOn: aCanvas
 
+ super drawOn: aCanvas.
+
+ self showHandle ifTrue: [
+ self orientation = #vertical ifTrue: [
+ aCanvas
+ fillRoundRect: (((self width @ (self height * 0.25 min: self class handleLength)) center: self center) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor)].
+ self orientation = #horizontal ifTrue: [
+ aCanvas
+ fillRoundRect: ((((self width * 0.25 min: self class handleLength) @ self height) center: self center) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor)] ].!
- "aCanvas fillRectangle: self bounds color: Color red" "for debugging"
- !

Item was added:
+ ----- Method: BorderGripMorph>>handleInset (in category 'accessing') -----
+ handleInset
+
+ ^ (handleInset notNil or: [self owner isNil])
+ ifTrue: [handleInset ifNil: [2]]
+ ifFalse: [(self owner borderWidth max: 1) * 2]!

Item was added:
+ ----- Method: BorderGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ super layoutProportionallyIn: cellBounds.
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct properties at this time."
+ self orientation = #vertical ifTrue: [
+ self width: self class gripThickness + (self owner borderWidth * 2)].
+ self orientation = #horizontal ifTrue: [
+ self height: self class gripThickness + (self owner borderWidth * 2)].
+ !

Item was added:
+ ----- Method: BorderGripMorph>>orientation (in category 'accessing') -----
+ orientation
+ "#vertical or #horizontal"
+
+ self subclassResponsibility.!

Item was removed:
- ----- Method: BorderGripMorph>>setDefaultColors (in category 'private') -----
- setDefaultColors!

Item was removed:
- ----- Method: BorderGripMorph>>setInverseColors (in category 'private') -----
- setInverseColors!

Item was added:
+ ----- Method: BorderGripMorph>>showHandle (in category 'accessing') -----
+ showHandle
+
+ ^ showHandle ifNil: [
+ self flag: #migration. "mt: Can be simplified with a later update."
+ (self class respondsTo: #drawEdgeResizeHandles)
+ ifTrue: [self class drawEdgeResizeHandles]
+ ifFalse: [false]]!

Item was changed:
  ----- Method: BottomGripMorph>>apply: (in category 'target resize') -----
  apply: delta
  | oldBounds |
+ oldBounds := self target bounds.
+ self target
- oldBounds := target bounds.
- target
  bounds: (oldBounds origin corner: oldBounds corner + (0 @ delta y))!

Item was changed:
  ----- Method: BottomGripMorph>>gripLayoutFrame (in category 'accessing') -----
  gripLayoutFrame
  ^ LayoutFrame
  fractions: (0 @ 1 corner: 1 @ 1)
+ offsets: (0 @ 0 corner: 0 @ 0)!
- offsets: (0 @ 0 negated corner: 0@ self defaultHeight)!

Item was added:
+ ----- Method: BottomGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ super layoutProportionallyIn: cellBounds.
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct new bounds at this time."
+ self bottom: owner bottom.!

Item was added:
+ ----- Method: BottomGripMorph>>orientation (in category 'accessing') -----
+ orientation
+
+ ^ #horizontal!

Item was changed:
  ----- Method: BottomLeftGripMorph>>apply: (in category 'target resize') -----
  apply: delta
  | oldBounds |
+ oldBounds := self target bounds.
+ self target
- oldBounds := target bounds.
- target
  bounds: (oldBounds origin + (delta x @ 0) corner: oldBounds corner + (0 @ delta y))!

Item was removed:
- ----- Method: BottomLeftGripMorph>>borderOffset (in category 'private') -----
- borderOffset
- |width|
- width :=SystemWindow borderWidth +1.
- ^self handleOrigin + (width @ width negated)!

Item was added:
+ ----- Method: BottomLeftGripMorph>>drawOn: (in category 'drawing') -----
+ drawOn: aCanvas
+
+ super drawOn: aCanvas.
+
+ self showHandle ifTrue: [
+ aCanvas
+ fillRoundRect: ((self topLeft + (self handleInset @ self handleInset negated) extent: self class gripThickness @ self height) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor).
+ aCanvas
+ fillRoundRect: ((self bottomLeft + (self handleInset @ (self handleInset negated + self class gripThickness negated)) extent: self width @ self class gripThickness) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor).]!

Item was changed:
  ----- Method: BottomLeftGripMorph>>gripLayoutFrame (in category 'accessing') -----
  gripLayoutFrame
  ^ LayoutFrame
  fractions: (0 @ 1 corner: 0 @ 1)
+ offsets: (0 @ 0 corner: 0 @ 0)!
- offsets: (self class gripThickness negated @ (self defaultHeight negated + self class gripThickness)
- corner: 0 @ 0)!

Item was removed:
- ----- Method: BottomLeftGripMorph>>handleOrigin (in category 'private') -----
- handleOrigin
- ^25@0!

Item was added:
+ ----- Method: BottomLeftGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct new bounds at this time."
+ self bottomLeft: owner bottomLeft.!

Item was changed:
  ----- Method: BottomRightGripMorph>>apply: (in category 'target resize') -----
  apply: delta
  | oldBounds |
+ oldBounds := self target bounds.
+ self target
- oldBounds := target bounds.
- target
  bounds: (oldBounds origin corner: oldBounds corner + delta)!

Item was removed:
- ----- Method: BottomRightGripMorph>>borderOffset (in category 'private') -----
- borderOffset
- |width|
- width :=SystemWindow borderWidth +1.
- ^self handleOrigin - (width asPoint)!

Item was added:
+ ----- Method: BottomRightGripMorph>>drawOn: (in category 'drawing') -----
+ drawOn: aCanvas
+
+ super drawOn: aCanvas.
+
+ self showHandle ifTrue: [
+ aCanvas
+ fillRoundRect: ((self topRight + ((self handleInset negated + self class gripThickness negated) @ self handleInset negated) extent: self class gripThickness @ self height) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor).
+ aCanvas
+ fillRoundRect: ((self bottomLeft + (self handleInset negated @ (self handleInset negated + self class gripThickness negated)) extent: self width @ self class gripThickness) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor).]!

Item was changed:
  ----- Method: BottomRightGripMorph>>gripLayoutFrame (in category 'accessing') -----
  gripLayoutFrame
  ^ LayoutFrame
  fractions: (1 @ 1 corner: 1 @ 1)
+ offsets: (0 @ 0 corner: 0 @ 0)!
- offsets: ((self defaultWidth negated + self class gripThickness) @ (self defaultHeight negated + self class gripThickness)
- corner: 0@0)!

Item was removed:
- ----- Method: BottomRightGripMorph>>handleOrigin (in category 'private') -----
- handleOrigin
- ^0@0!

Item was added:
+ ----- Method: BottomRightGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct new bounds at this time."
+ self bottomRight: owner bottomRight.!

Item was changed:
  AbstractResizerMorph subclass: #CornerGripMorph
  instanceVariableNames: 'target'
+ classVariableNames: 'DrawCornerResizeHandles DrawEdgeResizeHandles'
- classVariableNames: 'ActiveForm DrawCornerResizeHandles PassiveForm'
  poolDictionaries: ''
  category: 'Morphic-Windows'!
 
  !CornerGripMorph commentStamp: 'jmv 1/29/2006 17:15' prior: 0!
  I am the superclass of a hierarchy of morph specialized in allowing the user to resize windows.!

Item was removed:
- ----- Method: CornerGripMorph class>>activeColor (in category 'handle settings') -----
- activeColor
- <preference: 'Corner Grip highlight color'
- category: 'colors'
- description: 'The highlight-color of window corners'
- type: #Color>
- ^(self activeForm colorAt: 24@24) alpha:  1!

Item was removed:
- ----- Method: CornerGripMorph class>>activeColor: (in category 'handle settings') -----
- activeColor: aColor
- |canvas|
- canvas := self initializeActiveForm getCanvas.
- canvas
- privatePort fillPattern: aColor;
- combinationRule: Form rgbMul;
- fillRect: (self activeForm boundingBox) offset: 0@0.
-
- !

Item was removed:
- ----- Method: CornerGripMorph class>>activeForm (in category 'accessing') -----
- activeForm
- ^ActiveForm ifNil: [self initializeActiveForm]!

Item was removed:
- ----- Method: CornerGripMorph class>>defaultForm (in category 'class initialization') -----
(excessive size, no diff calculated)

Item was removed:
- ----- Method: CornerGripMorph class>>defaultFormFromFileNamed: (in category 'handle settings') -----
- defaultFormFromFileNamed: aString
- "If you dislike the alpha scale of the default handle, use this method to install a new one.
- File should be in a readable image format, and contain a 48x48 32bit radial gradient with color white.
- Use passiveColor: / activeColor: to change them after file is loaded, see initialize for an example"
-
- |sourceStream|
- sourceStream := WriteStream on: String new.
- sourceStream nextPutAll: 'defaultForm';
- nextPut: Character cr;
- nextPut: Character cr;
- nextPut: $^;
- nextPut: $(;
- nextPutAll: (ImageReadWriter formFromFileNamed: aString) storeString;
- nextPut: $).
- self class compile: sourceStream contents.!

Item was added:
+ ----- Method: CornerGripMorph class>>drawEdgeResizeHandles (in category 'preferences') -----
+ drawEdgeResizeHandles
+ <preference: 'Draw Edge Resize Handles'
+ category: 'windows'
+ description: 'Set whether the resize handles on windows should be drawn on the window frame. This does not enable nor disable the resizing function.'
+ type: #Boolean>
+ ^ DrawEdgeResizeHandles ifNil: [ false ]!

Item was added:
+ ----- Method: CornerGripMorph class>>drawEdgeResizeHandles: (in category 'preferences') -----
+ drawEdgeResizeHandles: aBoolean
+
+ DrawEdgeResizeHandles := aBoolean.
+ Project current restoreDisplay.!

Item was removed:
- ----- Method: CornerGripMorph class>>initialize (in category 'class initialization') -----
- initialize
- "CornerGripMorph initialize"
-
- super initialize.
- self initializeActiveForm.
- self initializePassiveForm.
- self activeColor: Color orange.!

Item was removed:
- ----- Method: CornerGripMorph class>>initializeActiveForm (in category 'class initialization') -----
- initializeActiveForm
-
- ^ActiveForm := self defaultForm!

Item was removed:
- ----- Method: CornerGripMorph class>>initializePassiveForm (in category 'class initialization') -----
- initializePassiveForm
-
- ^PassiveForm := self defaultForm!

Item was removed:
- ----- Method: CornerGripMorph class>>passiveColor (in category 'handle settings') -----
- passiveColor
- <preference: 'Corner Grip color'
- category: 'colors'
- description: 'The default color of window corners'
- type: #Color>
- ^(self passiveForm colorAt: 24@24) alpha:  1!

Item was removed:
- ----- Method: CornerGripMorph class>>passiveColor: (in category 'handle settings') -----
- passiveColor: aColor
- | canvas |
- canvas := self initializePassiveForm getCanvas.
- canvas privatePort fillPattern: aColor;
- combinationRule: Form rgbMul;
- fillRect: self passiveForm boundingBox offset: 0 @ 0.
- self
- allSubInstancesDo: [:each | each setDefaultColors; changed]!

Item was removed:
- ----- Method: CornerGripMorph class>>passiveForm (in category 'accessing') -----
- passiveForm
- ^PassiveForm ifNil: [self initializePassiveForm]!

Item was removed:
- ----- Method: CornerGripMorph>>activeForm (in category 'private') -----
- activeForm
- ^self clipForm: self class activeForm!

Item was removed:
- ----- Method: CornerGripMorph>>alphaHandle (in category 'drawing') -----
- alphaHandle
-
- handleColor ifNil: [handleColor := self passiveForm].
- "The following line is only needed on first load, so existing windows don't blow up from the new handles.
- Can safely be deleted along with this comment in a later update"
- (handleColor class == Form)
- ifFalse: [handleColor := self passiveForm].
- ^handleColor
-
-
- !

Item was removed:
- ----- Method: CornerGripMorph>>borderOffset (in category 'private') -----
- borderOffset
- "The offset from my corner to where the border starts"
- ^self subclassResponsibility!

Item was removed:
- ----- Method: CornerGripMorph>>clipForm: (in category 'private') -----
- clipForm: aHandle
- |cutArea|
- "This doesn't really needs to be done every draw, but only if border width changes.
- In that case,, we'd have to install a newly initialized one anyways, so the current method will fail.
- Good enough for now though."
- cutArea := self transparentRectangle.
- aHandle getCanvas image: cutArea
- at: self borderOffset
- sourceRect: cutArea boundingBox
- rule: Form and.
- ^aHandle
-
- !

Item was changed:
  ----- Method: CornerGripMorph>>defaultHeight (in category 'accessing') -----
  defaultHeight
 
+ ^ self class handleLength!
- ^ self class gripThickness * 6!

Item was changed:
  ----- Method: CornerGripMorph>>defaultWidth (in category 'accessing') -----
  defaultWidth
 
+ ^ self class handleLength!
- ^ self class gripThickness * 6!

Item was changed:
  ----- Method: CornerGripMorph>>drawOn: (in category 'drawing') -----
  drawOn: aCanvas
 
+ "self showHandle
- self drawCornerResizeHandles
  ifTrue: [
  bounds := self bounds.
  aCanvas
+ translucentImage: self alphaHandle
+ at: self topLeft
+ sourceRect: (self handleOrigin + (1@1) extent: self extent)]"!
- translucentImage: (self alphaHandle)
- at: (bounds origin )
- sourceRect: (self handleOrigin extent: bounds extent)]!

Item was added:
+ ----- Method: CornerGripMorph>>handleInset (in category 'accessing') -----
+ handleInset
+
+ ^ (handleInset notNil or: [self owner isNil])
+ ifTrue: [handleInset ifNil: [1]]
+ ifFalse: [self owner borderWidth max: 1]!

Item was removed:
- ----- Method: CornerGripMorph>>handleOrigin (in category 'private') -----
- handleOrigin
- "The handles origin is the offset into the alphaForm"
- ^self subclassResponsibility!

Item was changed:
  ----- Method: CornerGripMorph>>initialize (in category 'initialization') -----
  initialize
+
  super initialize.
+ self extent: self defaultWidth @ self defaultHeight.
+ self layoutFrame: self gripLayoutFrame.!
- self extent: self defaultWidth+2 @ (self defaultHeight+2).
- self layoutFrame: self gripLayoutFrame!

Item was changed:
  ----- Method: CornerGripMorph>>mouseDown: (in category 'event handling') -----
  mouseDown: anEvent
+ "Disable drop shadow to improve performance while resizing."
- "Disable drop shadow to improve performance."
 
  super mouseDown: anEvent.
 
+ self target ifNil: [^ self].
+ self target fastFramingOn ifFalse: [
- target ifNil: [^ self].
- target fastFramingOn ifFalse: [
  self setProperty: #targetHadDropShadow toValue: target hasDropShadow.
+ self target hasDropShadow: false].!
- target hasDropShadow: false].!

Item was changed:
  ----- Method: CornerGripMorph>>mouseMove: (in category 'event handling') -----
  mouseMove: anEvent
+
  | delta |
+ self target ifNil: [^ self].
+ self target fastFramingOn
+ ifTrue: [delta := self target doFastWindowReframe: self ptName]
- target ifNil: [^ self].
- target fastFramingOn
- ifTrue: [delta := target doFastWindowReframe: self ptName]
  ifFalse: [
+ delta := self referencePoint ifNil: [0@0] ifNotNil: [anEvent position - self referencePoint].
+ self referencePoint: anEvent position.
- delta := lastMouse ifNil: [0@0] ifNotNil: [anEvent cursorPoint - lastMouse].
- lastMouse := anEvent cursorPoint.
  self apply: delta.
  self bounds: (self bounds origin + delta extent: self bounds extent)].!

Item was changed:
  ----- Method: CornerGripMorph>>mouseUp: (in category 'event handling') -----
  mouseUp: anEvent
+ "Restore target drop shadow if there was one. See #mouseDown:."
+
+ self target ifNil: [^ self].
+ self target fastFramingOn ifFalse: [
+ (self valueOfProperty: #targetHadDropShadow ifAbsent: [false]) ifTrue: [self target hasDropShadow: true].
-
- target ifNil: [^ self].
- target fastFramingOn ifFalse: [
- (self valueOfProperty: #targetHadDropShadow ifAbsent: [false]) ifTrue: [target hasDropShadow: true].
  self removeProperty: #targetHadDropShadow].!

Item was removed:
- ----- Method: CornerGripMorph>>passiveForm (in category 'private') -----
- passiveForm
- ^self clipForm: self class passiveForm!

Item was removed:
- ----- Method: CornerGripMorph>>setDefaultColors (in category 'private') -----
- setDefaultColors
-
- handleColor := self passiveForm.!

Item was removed:
- ----- Method: CornerGripMorph>>setInverseColors (in category 'private') -----
- setInverseColors
- handleColor := self activeForm.!

Item was added:
+ ----- Method: CornerGripMorph>>showHandle (in category 'accessing') -----
+ showHandle
+
+ ^ showHandle ifNil: [self class drawCornerResizeHandles]!

Item was added:
+ ----- Method: CornerGripMorph>>target (in category 'accessing') -----
+ target
+
+ ^ target!

Item was changed:
+ ----- Method: CornerGripMorph>>target: (in category 'accessing') -----
- ----- Method: CornerGripMorph>>target: (in category 'accessing-backstop') -----
  target: aMorph
 
  target := aMorph!

Item was removed:
- ----- Method: CornerGripMorph>>transparentRectangle (in category 'private') -----
- transparentRectangle
- "This could be a class var, provided either bounds of grips does not change, or one ensures a new one is installed when such an event occurs"
- ^Form extent: self bounds extent depth: 32!

Item was changed:
  ----- Method: FillInTheBlankMorph>>setQuery:initialAnswer:answerExtent:acceptOnCR: (in category 'initialization') -----
  setQuery: queryString initialAnswer: initialAnswer answerExtent: answerExtent acceptOnCR: acceptBoolean
 
  | text |
 
  result := initialAnswer.
  done := false.
 
  self paneMorph removeAllMorphs.
 
  self title: 'Input Requested' translated.
  self message: queryString.
 
  text := self createTextPaneAcceptOnCR: acceptBoolean.
  self paneMorph addMorphBack: text.
 
  self paneMorph
  wantsPaneSplitters: true;
  addCornerGrips.
+ self paneMorph grips do: [:ea | ea showHandle: true].
- self paneMorph grips do: [:ea | ea drawCornerResizeHandles: true].
 
  self paneMorph extent: ((initialAnswer asText asMorph extent + (20@10) max: answerExtent) min: 500@500).
  self setDefaultParameters.!

Item was changed:
  ----- Method: LeftGripMorph>>apply: (in category 'target resize') -----
  apply: delta
  | oldBounds |
+ oldBounds := self target bounds.
+ self target
- oldBounds := target bounds.
- target
  bounds: (oldBounds origin + (delta x @ 0) corner: oldBounds corner)!

Item was changed:
  ----- Method: LeftGripMorph>>gripLayoutFrame (in category 'accessing') -----
  gripLayoutFrame
  ^ LayoutFrame
  fractions: (0 @ 0 corner: 0 @ 1)
+ offsets: (0 @ 0 corner: 0 @ 0)!
- offsets: (self defaultWidth negated @ 0 corner: 0 @ 0)!

Item was added:
+ ----- Method: LeftGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ super layoutProportionallyIn: cellBounds.
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct new bounds at this time."
+ self left: owner left.
+
+ self top: owner top.
+ self height: owner height.!

Item was added:
+ ----- Method: LeftGripMorph>>orientation (in category 'accessing') -----
+ orientation
+
+ ^ #vertical!

Item was changed:
  AbstractResizerMorph subclass: #ProportionalSplitterMorph
+ instanceVariableNames: 'leftOrTop rightOrBottom splitsTopAndBottom traceMorph movements'
- instanceVariableNames: 'leftOrTop rightOrBottom splitsTopAndBottom oldColor traceMorph handle movements'
  classVariableNames: 'SmartHorizontalSplitters SmartVerticalSplitters'
  poolDictionaries: ''
  category: 'Morphic-Windows'!
 
  !ProportionalSplitterMorph commentStamp: 'jmv 1/29/2006 17:16' prior: 0!
  I am the morph the user grabs to adjust pane splitters.!

Item was changed:
  ----- Method: ProportionalSplitterMorph class>>fastSplitterResize (in category 'preferences') -----
  fastSplitterResize
 
+ ^ Preferences fastDragWindowForMorphic!
- ^ Preferences fastDragWindowForMorphic.!

Item was added:
+ ----- Method: ProportionalSplitterMorph class>>showSplitterHandles: (in category 'preferences') -----
+ showSplitterHandles: aBoolean
+
+ Preferences setPreference: #showSplitterHandles toValue: aBoolean.
+ Project current restoreDisplay.!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>addLeftOrTop: (in category 'initialization') -----
- ----- Method: ProportionalSplitterMorph>>addLeftOrTop: (in category 'controlled morphs') -----
  addLeftOrTop: aMorph
 
  leftOrTop add: aMorph!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>addRightOrBottom: (in category 'initialization') -----
- ----- Method: ProportionalSplitterMorph>>addRightOrBottom: (in category 'controlled morphs') -----
  addRightOrBottom: aMorph
 
  rightOrBottom add: aMorph.
 
  !

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>balanceOffsets (in category 'events') -----
- ----- Method: ProportionalSplitterMorph>>balanceOffsets (in category 'layout') -----
  balanceOffsets
 
  | fdx fdy |
 
  (self hasProperty: #fullDelta) ifFalse: [^ self].
 
  fdx := (self valueOfProperty: #fullDelta) x.
  fdy := (self valueOfProperty: #fullDelta) y.
 
  self layoutFrame hasFixedHeight ifTrue: [
  | otop obot ctop cbot topf |
 
  otop := (owner submorphs detect: [:m |
  m layoutFrame topFraction isZero] ifNone: [^ self]) in: [:tm |
  tm top - (tm layoutFrame topOffset ifNil: [0])].
 
  obot := (owner submorphs detect: [:m |
  m layoutFrame bottomFraction = 1] ifNone: [^ self]) in: [:tm |
  tm bottom - (tm layoutFrame bottomOffset ifNil: [0])].
 
  ctop := (self layoutFrame topFraction * (obot - otop)) rounded
  + otop + (self layoutFrame topOffset ifNil: [0]).
  cbot := (self layoutFrame bottomFraction * (obot - otop)) rounded
  + otop + (self layoutFrame bottomOffset ifNil: [0]).
 
  topf := self layoutFrame topFraction.
  self layoutFrame topFraction:  ((ctop + cbot) * 0.5 - otop) / (obot - otop) asFloat.
  self layoutFrame bottomFraction: self layoutFrame topFraction.
  self layoutFrame topOffset: self layoutFrame topOffset - fdy.
  self layoutFrame bottomOffset: self layoutFrame bottomOffset - fdy.
 
  (leftOrTop copy union: rightOrBottom) do: [:m |
  (m layoutFrame topFraction closeTo: topf) ifTrue: [
  m layoutFrame topFraction: self layoutFrame topFraction.
  m layoutFrame topOffset: m layoutFrame topOffset - fdy].
  (m layoutFrame bottomFraction closeTo: topf) ifTrue: [
  m layoutFrame bottomFraction: self layoutFrame topFraction.
  m layoutFrame bottomOffset: m layoutFrame bottomOffset - fdy]]] .
 
  self layoutFrame hasFixedWidth ifTrue: [
  | oleft oright cleft cright leftf |
 
  oleft := (owner submorphs detect: [:m |
  m layoutFrame leftFraction isZero] ifNone: [^ self]) in: [:tm |
  tm left - (tm layoutFrame leftOffset ifNil: [0])].
 
  oright := (owner submorphs detect: [:m |
  m layoutFrame rightFraction = 1] ifNone: [^ self]) in: [:tm |
  tm right - (tm layoutFrame rightOffset ifNil: [0])].
 
  cleft := (self layoutFrame leftFraction * (oright - oleft)) rounded
  + oleft + (self layoutFrame leftOffset ifNil: [0]).
  cright := (self layoutFrame rightFraction * (oright - oleft)) rounded
  + oleft + (self layoutFrame rightOffset ifNil: [0]).
 
  leftf := self layoutFrame leftFraction.
  self layoutFrame leftFraction: ((cleft + cright) * 0.5 - oleft) / (oright - oleft) asFloat.
  self layoutFrame rightFraction: self layoutFrame leftFraction.
 
 
  self layoutFrame leftOffset: self layoutFrame leftOffset - fdx.
  self layoutFrame rightOffset: self layoutFrame rightOffset - fdx.
 
  (leftOrTop copy union: rightOrBottom) do: [:m |
  (m layoutFrame leftFraction closeTo: leftf) ifTrue: [
  m layoutFrame leftFraction: self layoutFrame leftFraction.
  m layoutFrame leftOffset: m layoutFrame leftOffset - fdx].
  (m layoutFrame rightFraction closeTo: leftf) ifTrue: [
  m layoutFrame rightFraction: self layoutFrame leftFraction.
  m layoutFrame rightOffset: m layoutFrame rightOffset - fdx.]]] .
 
  self removeProperty: #fullDelta.
  owner layoutChanged
  !

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>beSplitsLeftAndRight (in category 'initialization') -----
- ----- Method: ProportionalSplitterMorph>>beSplitsLeftAndRight (in category 'direction') -----
  beSplitsLeftAndRight
 
  splitsTopAndBottom := false.
  self
  hResizing: #rigid;
  vResizing: #spaceFill.
  self width: self class gripThickness.!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>beSplitsTopAndBottom (in category 'initialization') -----
- ----- Method: ProportionalSplitterMorph>>beSplitsTopAndBottom (in category 'direction') -----
  beSplitsTopAndBottom
 
  splitsTopAndBottom := true.
  self
  vResizing: #rigid;
  hResizing: #spaceFill.
  self height: self class gripThickness.!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>bordersOn: (in category 'queries - controlled morphs') -----
- ----- Method: ProportionalSplitterMorph>>bordersOn: (in category 'controlled morphs') -----
  bordersOn: aMorph
  "Answer true if the aMorph is one of my neighbours."
 
  ^ (leftOrTop includes: aMorph) or: [rightOrBottom includes: aMorph]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>bottomBoundary (in category 'queries - geometry') -----
- ----- Method: ProportionalSplitterMorph>>bottomBoundary (in category 'boundaries') -----
  bottomBoundary
  "Answert the bottommost x position the receiver could be moved."
 
  | splitter morphs |
  splitter := self splitterBelow.
  morphs := self commonNeighbours: rightOrBottom with: splitter.
  ^ (splitter
  ifNil: [owner isSystemWindow ifTrue: [owner panelRect bottom]
  ifFalse: [owner innerBounds bottom]]
  ifNotNil: [splitter top])
  - (self minimumHeightOf: morphs)!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>canEncroachWhiteSpaceOf: (in category 'smart splitters - queries') -----
- ----- Method: ProportionalSplitterMorph>>canEncroachWhiteSpaceOf: (in category 'layout') -----
  canEncroachWhiteSpaceOf: morphs
  ^ morphs allSatisfy: [ : each | each canBeEncroached ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>charactersOccludedIn: (in category 'smart splitters - queries') -----
- ----- Method: ProportionalSplitterMorph>>charactersOccludedIn: (in category 'layout') -----
  charactersOccludedIn: aCollection
  ^ aCollection
  inject: 0
  into:
  [ : sum : each | sum +
  (each isMorphicModel
  ifTrue: [ each charactersOccluded ]
  ifFalse: [ 0 ]) ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>commonNeighbours:with: (in category 'queries - controlled morphs') -----
- ----- Method: ProportionalSplitterMorph>>commonNeighbours:with: (in category 'controlled morphs') -----
  commonNeighbours: morphs with: aProportionalSplitterMorphOrNil
  "Answer the subset of morphs which is also confined by aProportionalSplitterMorphOrNil."
 
  ^ aProportionalSplitterMorphOrNil isNil
  ifTrue: [morphs]
  ifFalse: [morphs select: [ :which |
  aProportionalSplitterMorphOrNil bordersOn: which]]!

Item was added:
+ ----- Method: ProportionalSplitterMorph>>drawOn: (in category 'drawing') -----
+ drawOn: aCanvas
+
+ super drawOn: aCanvas.
+
+ self showHandle ifTrue: [
+ self splitsLeftAndRight ifTrue: [
+ aCanvas
+ fillRoundRect: (((self width - (self handleInset * 2) max: 1) @ (self height * 0.25 min: self class handleLength)) center: self center)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor)].
+ self splitsTopAndBottom ifTrue: [
+ aCanvas
+ fillRoundRect: (((self width * 0.25 min: self class handleLength) @ (self height - (self handleInset * 2) max: 1)) center: self center)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor)] ].!

Item was removed:
- ----- Method: ProportionalSplitterMorph>>getOldColor (in category 'displaying') -----
- getOldColor
- ^ oldColor ifNil: [Color transparent]!

Item was removed:
- ----- Method: ProportionalSplitterMorph>>handleRect (in category 'displaying') -----
- handleRect
-
- ^ Rectangle
- center: self bounds center
- extent: (self splitsTopAndBottom
- ifTrue: [self handleSize transposed]
- ifFalse: [self handleSize])!

Item was removed:
- ----- Method: ProportionalSplitterMorph>>handleSize (in category 'displaying') -----
- handleSize
-
- ^ self class gripThickness @ 30!

Item was changed:
  ----- Method: ProportionalSplitterMorph>>initialize (in category 'initialization') -----
  initialize
 
  super initialize.
 
  self beSplitsLeftAndRight.
 
  leftOrTop := OrderedCollection new.
  rightOrBottom := OrderedCollection new.
 
+ self initializeMovements.!
- Preferences showSplitterHandles
- ifTrue: [
- handle := CircleMorph new
- borderWidth: 0;
- extent: 4@4;
- yourself.
- handle fillStyle: ((GradientFillStyle
- ramp: {0.0 -> Color veryVeryLightGray muchLighter.
- 1.0 -> Color veryVeryLightGray darker})
- origin: handle topLeft;
- direction: 0 @ handle bounds extent y;
- normal: handle bounds extent x @ 0;
- radial: false;
- yourself).
- self addMorphCentered: handle].
- self initializeMovements!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>initializeMovements (in category 'smart splitters') -----
- ----- Method: ProportionalSplitterMorph>>initializeMovements (in category 'initialization') -----
  initializeMovements
  movements := OrderedCollection new: 3 withAll: 0!

Item was removed:
- ----- Method: ProportionalSplitterMorph>>isCursorOverHandle (in category 'testing') -----
- isCursorOverHandle
- ^ self class showSplitterHandles not or: [self handleRect containsPoint: ActiveHand cursorPoint]!

Item was removed:
- ----- Method: ProportionalSplitterMorph>>layoutChanged (in category 'layout') -----
- layoutChanged
-
- super layoutChanged.
- handle ifNotNil: [handle position: self bounds center - (2@2)]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>leftBoundary (in category 'queries - geometry') -----
- ----- Method: ProportionalSplitterMorph>>leftBoundary (in category 'boundaries') -----
  leftBoundary
  "Answer the leftmost y position the receiver could be moved."
 
  | splitter morphs |
  splitter := self splitterLeft.
  morphs := self commonNeighbours: leftOrTop with: splitter.
  ^ (splitter
  ifNil: [owner isSystemWindow ifTrue: [owner panelRect left]
  ifFalse: [owner innerBounds left]]
  ifNotNil: [splitter right])
  + (self minimumWidthOf: morphs)!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>leftRightImbalance (in category 'smart splitters - queries') -----
- ----- Method: ProportionalSplitterMorph>>leftRightImbalance (in category 'layout') -----
  leftRightImbalance
  "First check if I find myself out of range due to user having reduced size of parent."
  ^ self left < self leftBoundary "too far left"
  ifTrue: [ self leftBoundary-self left ]
  ifFalse:
  [ self right > self rightBoundary "too far right"
  ifTrue: [ self rightBoundary-self right ]
  ifFalse: [ self occlusionDifference ] ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>minimumHeightOf: (in category 'queries - geometry') -----
- ----- Method: ProportionalSplitterMorph>>minimumHeightOf: (in category 'boundaries') -----
  minimumHeightOf: aCollection
  "Answer the minimum height needed to display any of the morphs in aCollection.
  See ProportionalLayout >> #minExtentOf:in:."
 
  ^ aCollection inject: 0 into: [ :height :morph |
  | minHeight |
  minHeight := morph minHeight.
  "morph layoutFrame ifNotNil: [:frame |
  minHeight := frame minHeightFrom: minHeight]."
  minHeight + self height max: height]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>minimumWidthOf: (in category 'queries - geometry') -----
- ----- Method: ProportionalSplitterMorph>>minimumWidthOf: (in category 'boundaries') -----
  minimumWidthOf: aCollection
  "Answer the minimum width needed to display any of the morphs in aCollection.
  See ProportionalLayout >> #minExtentOf:in:."
 
  ^ aCollection inject: 0 into: [ :width :morph |
  | minWidth |
  minWidth := morph minWidth.
  "morph layoutFrame ifNotNil: [:frame |
  minWidth := frame minWidthFrom: minWidth]."
  minWidth + self width max: width]!

Item was changed:
  ----- Method: ProportionalSplitterMorph>>mouseDown: (in category 'events') -----
  mouseDown: anEvent
  "If the user manually drags me, don't override him with auto positioning."
 
  self setProperty: #fullDelta toValue: 0@0.
 
  anEvent redButtonChanged
  ifTrue: [ self withSiblingSplittersDo: [ : each | each stopStepping ] ]
  ifFalse:
  [ anEvent shiftPressed
  ifTrue: [ self startStepping ]
  ifFalse:
  [ self startStepping.
  self withSiblingSplittersDo: [ : each | each startStepping ] ] ].
+
- (self class showSplitterHandles not and: [ self bounds containsPoint: anEvent cursorPoint ]) ifTrue:
- [ oldColor := self color.
- self color: Color black ].
  ^ super mouseDown: anEvent!

Item was changed:
  ----- Method: ProportionalSplitterMorph>>mouseUp: (in category 'events') -----
  mouseUp: anEvent
  (self bounds containsPoint: anEvent cursorPoint) ifFalse: [ anEvent hand showTemporaryCursor: nil ].
  self class fastSplitterResize ifTrue: [ self updateFromEvent: anEvent ].
  traceMorph ifNotNil:
  [ traceMorph delete.
  traceMorph := nil ].
+
- self color: self getOldColor.
  "balanceOffsets currently disrupts Smart Splitter behavior."
  (ProportionalSplitterMorph smartVerticalSplitters or: [ ProportionalSplitterMorph smartHorizontalSplitters ]) ifFalse: [ self balanceOffsets ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>movements (in category 'smart splitters') -----
- ----- Method: ProportionalSplitterMorph>>movements (in category 'layout') -----
  movements
  "Used to track my pattern of movement for the last 3 steps to fix the twitching."
  "Lazy-init for now for smooth transition -- want to convert this back to direct-var access after a few months."
  ^ movements ifNil: [ self initializeMovements. movements ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>normalizedX: (in category 'queries - geometry') -----
- ----- Method: ProportionalSplitterMorph>>normalizedX: (in category 'boundaries') -----
  normalizedX: x
 
  ^ (x max: self leftBoundary) min: self rightBoundary!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>normalizedY: (in category 'queries - geometry') -----
- ----- Method: ProportionalSplitterMorph>>normalizedY: (in category 'boundaries') -----
  normalizedY: y
 
  ^ (y max: self topBoundary) min: self bottomBoundary!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>occlusionDifference (in category 'smart splitters - queries') -----
- ----- Method: ProportionalSplitterMorph>>occlusionDifference (in category 'events') -----
  occlusionDifference
  ^ (self charactersOccludedIn: leftOrTop) - (self charactersOccludedIn: rightOrBottom)!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>proposedCorrectionWouldCauseFocusChange: (in category 'smart splitters - queries') -----
- ----- Method: ProportionalSplitterMorph>>proposedCorrectionWouldCauseFocusChange: (in category 'layout') -----
  proposedCorrectionWouldCauseFocusChange: correction
  ^ Preferences mouseOverForKeyboardFocus and:
  [ | edge | splitsTopAndBottom
  ifTrue:
  [ edge := correction positive
  ifTrue: [ self bottom + 3 ]
  ifFalse: [ self top - 3 ].
  self activeHand position y
  inRangeOf: edge
  and: edge + correction ]
  ifFalse:
  [ edge := correction positive
  ifTrue: [ self right ]
  ifFalse: [ self left ].
  self activeHand position x
  inRangeOf: edge
  and: edge + correction ] ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>reduceLeftRightImbalance (in category 'smart splitters') -----
- ----- Method: ProportionalSplitterMorph>>reduceLeftRightImbalance (in category 'layout') -----
  reduceLeftRightImbalance
  | correction |
  correction := self leftRightImbalance.
  correction abs > 1
  ifTrue:
  [ (self proposedCorrectionWouldCauseFocusChange: correction) ifFalse:
  [ self repositionBy:
  (correction abs > 4
  ifTrue: [ correction sign * 2 @ 0 ]
  ifFalse: [ correction sign @ 0 ]) ] ]
  ifFalse:
  [ self class smartVerticalSplitters ifFalse: [ self stopStepping ] ].
  ^ correction!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>reduceTopBottomImbalance (in category 'smart splitters') -----
- ----- Method: ProportionalSplitterMorph>>reduceTopBottomImbalance (in category 'layout') -----
  reduceTopBottomImbalance
  | correction |
  (correction := self topBottomCorrection) isZero
  ifTrue:
  [ self class smartHorizontalSplitters ifFalse: [ self stopStepping ] ]
  ifFalse:
  [ (self proposedCorrectionWouldCauseFocusChange: correction) ifFalse: [ self repositionBy: 0 @ correction ] ].
  ^ correction!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>repositionBy: (in category 'events') -----
- ----- Method: ProportionalSplitterMorph>>repositionBy: (in category 'layout') -----
  repositionBy: delta
  | selfTop selfBottom selfLeft selfRight |
 
  self setProperty: #fullDelta toValue: ((self valueOfProperty: #fullDelta) ifNil: [0@0]) + delta.
 
  leftOrTop do:
  [ : each | | firstRight firstBottom firstLeft firstTop |
  firstRight := each layoutFrame rightOffset ifNil: [ 0 ].
  firstBottom := each layoutFrame bottomOffset ifNil: [ 0 ].
  each layoutFrame rightOffset: firstRight + delta x.
  each layoutFrame bottomOffset: firstBottom + delta y.
  each layoutFrame hasFixedHeight ifTrue: [
  firstTop := each layoutFrame topOffset ifNil: [ 0 ].
  each layoutFrame topOffset: firstTop + delta y ].
  each layoutFrame hasFixedWidth ifTrue: [
  firstLeft := each layoutFrame leftOffset ifNil: [ 0 ].
  each layoutFrame leftOffset: firstLeft + delta x. ] ].
  rightOrBottom do:
  [ : each | | secondLeft secondTop secondRight secondBottom |
  secondLeft := each layoutFrame leftOffset ifNil: [ 0 ].
  secondTop := each layoutFrame topOffset ifNil: [ 0 ].
  each layoutFrame leftOffset: secondLeft + delta x.
  each layoutFrame topOffset: secondTop + delta y.
  each layoutFrame hasFixedHeight ifTrue: [
  secondBottom := each layoutFrame bottomOffset ifNil: [ 0 ].
  each layoutFrame bottomOffset: secondBottom + delta y. ].
  each layoutFrame hasFixedWidth ifTrue: [
  secondRight := each layoutFrame rightOffset ifNil: [ 0 ].
  each layoutFrame rightOffset: secondRight + delta x. ] ].
 
  selfTop := self layoutFrame topOffset ifNil: [ 0 ].
  selfBottom := self layoutFrame bottomOffset ifNil: [ 0 ].
  selfLeft := self layoutFrame leftOffset ifNil: [ 0 ].
  selfRight := self layoutFrame rightOffset ifNil: [ 0 ].
  self layoutFrame
  topOffset: selfTop + delta y ;
  bottomOffset: selfBottom + delta y ;
  leftOffset: selfLeft + delta x ;
  rightOffset: selfRight + delta x.
  self owner layoutChanged.
  self movements removeFirst; add: (splitsTopAndBottom ifTrue: [ delta y sign ] ifFalse: [ delta x sign ])!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>resizeCursor (in category 'accessing') -----
- ----- Method: ProportionalSplitterMorph>>resizeCursor (in category 'displaying') -----
  resizeCursor
 
  ^ Cursor resizeForEdge: (splitsTopAndBottom
  ifTrue: [#top]
  ifFalse: [#left])
  !

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>rightBoundary (in category 'queries - geometry') -----
- ----- Method: ProportionalSplitterMorph>>rightBoundary (in category 'boundaries') -----
  rightBoundary
  "Answer the rightmost x position the receiver could be moved to."
 
  | splitter morphs |
  splitter := self splitterRight.
  morphs := self commonNeighbours: rightOrBottom with: splitter.
 
  ^ (splitter
  ifNil: [owner isSystemWindow ifTrue: [owner panelRect right]
  ifFalse: [owner innerBounds right]]
  ifNotNil: [splitter left])
  - (self minimumWidthOf: morphs)!

Item was added:
+ ----- Method: ProportionalSplitterMorph>>showHandle (in category 'accessing') -----
+ showHandle
+
+ ^ showHandle ifNil: [self class showSplitterHandles]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>siblingSplittersDo: (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>siblingSplittersDo: (in category 'adjacent splitters') -----
  siblingSplittersDo: aBlock
  owner ifNotNil:
  [ owner submorphsDo:
  [ : each | ((each isKindOf: self class) and:
  [ self splitsTopAndBottom = each splitsTopAndBottom and: [ each ~= self ] ]) ifTrue: [ aBlock value: each ] ] ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splitsLeftAndRight (in category 'testing') -----
- ----- Method: ProportionalSplitterMorph>>splitsLeftAndRight (in category 'direction') -----
  splitsLeftAndRight
 
  ^ self splitsTopAndBottom not!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splitsTopAndBottom (in category 'testing') -----
- ----- Method: ProportionalSplitterMorph>>splitsTopAndBottom (in category 'direction') -----
  splitsTopAndBottom
 
  ^ splitsTopAndBottom!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splitterAbove (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>splitterAbove (in category 'adjacent splitters') -----
  splitterAbove
  | immediatelyAbove |
  immediatelyAbove := nil.
  self siblingSplittersDo:
  [ : each | "Splitter y's map 0 at the bottom."
  each y > self y ifTrue:
  [ immediatelyAbove
  ifNil: [ immediatelyAbove := each ]
  ifNotNil:
  [ each y < immediatelyAbove y ifTrue: [ immediatelyAbove := each ] ] ] ].
  ^ immediatelyAbove!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splitterBelow (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>splitterBelow (in category 'adjacent splitters') -----
  splitterBelow
  | immediatelyBelow |
  immediatelyBelow := nil.
  self siblingSplittersDo:
  [ : each | each y < self y ifTrue:
  [ immediatelyBelow
  ifNil: [ immediatelyBelow := each ]
  ifNotNil:
  [ each y > immediatelyBelow y ifTrue: [ immediatelyBelow := each ] ] ] ].
  ^ immediatelyBelow!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splitterLeft (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>splitterLeft (in category 'adjacent splitters') -----
  splitterLeft
  | immediateLeft |
  immediateLeft := nil.
  self siblingSplittersDo:
  [ : each | each x < self x ifTrue:
  [ immediateLeft
  ifNil: [ immediateLeft := each ]
  ifNotNil:
  [ each x > immediateLeft x ifTrue: [ immediateLeft := each ] ] ] ].
  ^ immediateLeft!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splitterRight (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>splitterRight (in category 'adjacent splitters') -----
  splitterRight
  | immediateRight |
  immediateRight := nil.
  self siblingSplittersDo:
  [ : each | each x > self x ifTrue:
  [ immediateRight
  ifNil: [ immediateRight := each ]
  ifNotNil:
  [ each x < immediateRight x ifTrue: [ immediateRight := each ] ] ] ].
  ^ immediateRight!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splittersAboveDo: (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>splittersAboveDo: (in category 'adjacent splitters') -----
  splittersAboveDo: aBlock
  self splitterAbove ifNotNil:
  [ : splitter | aBlock value: splitter.
  splitter splittersAboveDo: aBlock ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splittersBelowDo: (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>splittersBelowDo: (in category 'adjacent splitters') -----
  splittersBelowDo: aBlock
  self splitterBelow ifNotNil:
  [ : splitter | aBlock value: splitter.
  splitter splittersBelowDo: aBlock ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splittersLeftDo: (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>splittersLeftDo: (in category 'adjacent splitters') -----
  splittersLeftDo: aBlock
  self splitterLeft ifNotNil:
  [ : splitter | aBlock value: splitter.
  splitter splittersLeftDo: aBlock ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>splittersRightDo: (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>splittersRightDo: (in category 'adjacent splitters') -----
  splittersRightDo: aBlock
  self splitterRight ifNotNil:
  [ : splitter | aBlock value: splitter.
  splitter splittersRightDo: aBlock ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>step (in category 'smart splitters - stepping') -----
- ----- Method: ProportionalSplitterMorph>>step (in category 'events') -----
  step
  splitsTopAndBottom
  ifTrue: [ self reduceTopBottomImbalance ]
  ifFalse:
  [ self reduceLeftRightImbalance abs > 1 ifTrue:
  [ self splittersLeftDo:
  [ : splitter | splitter reduceLeftRightImbalance ].
  self splittersRightDo:
  [ : splitter | splitter reduceLeftRightImbalance ] ] ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>stepTime (in category 'smart splitters - stepping') -----
- ----- Method: ProportionalSplitterMorph>>stepTime (in category 'events') -----
  stepTime
  "When a splitter finds itself in the right place, let it rest for about 3 seconds to avoid performance impacts of constant, rapid stepping."
  | pause |
  pause := 3000. "Frozen image when atRandom failed due to lock on its Mutex."
  ^ ({#(1 -1 1 ).  #(-1 1 -1 )} includes: self movements asArray)
  ifTrue: [ pause "don't twitch" ]
  ifFalse:
  [ splitsTopAndBottom
  ifTrue:
  [ self topBottomCorrection isZero
  ifTrue: [ pause ]
  ifFalse: [ 0 ] ]
  ifFalse:
  [ self leftRightImbalance abs > 1
  ifTrue: [ ">1 rather than 0 to discourage one-off twitching"
  0 ]
  ifFalse: [ pause ] ] ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>stopStepping (in category 'smart splitters - stepping') -----
- ----- Method: ProportionalSplitterMorph>>stopStepping (in category 'events') -----
  stopStepping
  super stopStepping.
  (self class smartVerticalSplitters or: [ self class smartHorizontalSplitters ]) ifFalse: [ self balanceOffsets ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>topBottomCorrection (in category 'smart splitters - queries') -----
- ----- Method: ProportionalSplitterMorph>>topBottomCorrection (in category 'layout') -----
  topBottomCorrection
  ^ self top < self topBoundary
  ifTrue: [ self topBoundary - self top ]
  ifFalse:
  [ self bottom > (self bottomBoundary)
  ifTrue: [ self bottomBoundary - self bottom ]
  ifFalse:
  [ | wsAbove wsBelow |
  wsAbove := self canEncroachWhiteSpaceOf: leftOrTop.
  wsBelow := self canEncroachWhiteSpaceOf: rightOrBottom.
  wsAbove
  ifTrue:
  [ wsBelow
  ifTrue:
  [ self splitterBelow
  ifNil: [0]
  ifNotNil: [ : below | below reduceTopBottomImbalance min: 0 ] ]
  ifFalse: [ (self top > self topBoundary) ifTrue: [-2] ifFalse: [0] ] ]
  ifFalse:
  [ wsBelow
  ifTrue: [ (self bottom < self bottomBoundary) ifTrue: [2] ifFalse: [0] ]
  ifFalse:
  [ self splitterBelow
  ifNil: [0]
  ifNotNil: [ : below | below reduceTopBottomImbalance max: 0 ] ] ] ] ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>topBoundary (in category 'queries - geometry') -----
- ----- Method: ProportionalSplitterMorph>>topBoundary (in category 'boundaries') -----
  topBoundary
  "Answer the topmost x position the receiver could be moved to."
 
  | splitter morphs |
  splitter := self splitterAbove.
  morphs := self commonNeighbours: leftOrTop with: splitter.
 
  ^ (splitter
  ifNil: [owner isSystemWindow ifTrue: [owner panelRect top]
  ifFalse: [owner innerBounds top]]
  ifNotNil: [splitter bottom])
  + (self minimumHeightOf: morphs)!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>wantsSteps (in category 'smart splitters - stepping') -----
- ----- Method: ProportionalSplitterMorph>>wantsSteps (in category 'events') -----
  wantsSteps
  ^ splitsTopAndBottom
  ifTrue: [ self class smartHorizontalSplitters ]
  ifFalse: [ self class smartVerticalSplitters ]!

Item was changed:
+ ----- Method: ProportionalSplitterMorph>>withSiblingSplittersDo: (in category 'queries - adjacent splitters') -----
- ----- Method: ProportionalSplitterMorph>>withSiblingSplittersDo: (in category 'adjacent splitters') -----
  withSiblingSplittersDo: aBlock
  aBlock value: self.
  self siblingSplittersDo: aBlock!

Item was changed:
  ----- Method: RightGripMorph>>apply: (in category 'target resize') -----
  apply: delta
  | oldBounds |
+ oldBounds := self target bounds.
+ self target
- oldBounds := target bounds.
- target
  bounds: (oldBounds origin corner: oldBounds corner + (delta x @ 0))!

Item was changed:
  ----- Method: RightGripMorph>>gripLayoutFrame (in category 'accessing') -----
  gripLayoutFrame
  ^ LayoutFrame
  fractions: (1 @ 0 corner: 1 @ 1)
+ offsets: (0 @ 0 corner: 0 @ 0)!
- offsets: (0 @ self defaultHeight negated corner: self defaultWidth @ 0)!

Item was added:
+ ----- Method: RightGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ super layoutProportionallyIn: cellBounds.
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct new bounds at this time."
+ self right: owner right.
+
+ self top: owner top.
+ self height: owner height.!

Item was added:
+ ----- Method: RightGripMorph>>orientation (in category 'accessing') -----
+ orientation
+
+ ^ #vertical!

Item was changed:
  ----- Method: TopGripMorph>>apply: (in category 'target resize') -----
  apply: delta
  | oldBounds |
+ oldBounds := self target bounds.
+ self target
- oldBounds := target bounds.
- target
  bounds: (oldBounds origin + (0 @ delta y) corner: oldBounds corner)!

Item was changed:
  ----- Method: TopGripMorph>>gripLayoutFrame (in category 'accessing') -----
  gripLayoutFrame
  ^ LayoutFrame
  fractions: (0 @ 0 corner: 1 @ 0)
+ offsets: (0 @ 0 corner: 0@ 0)!
- offsets: (0 @ (-40 - self defaultHeight)  corner: 0@ 0)!

Item was added:
+ ----- Method: TopGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ super layoutProportionallyIn: cellBounds.
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct new bounds at this time."
+ self top: owner top.!

Item was added:
+ ----- Method: TopGripMorph>>orientation (in category 'accessing') -----
+ orientation
+
+ ^ #horizontal!

Item was changed:
  ----- Method: TopLeftGripMorph>>apply: (in category 'target resize') -----
  apply: delta
  | oldBounds |
+ oldBounds := self target bounds.
+ self target
- oldBounds := target bounds.
- target
  bounds: (oldBounds origin + delta corner: oldBounds corner)!

Item was removed:
- ----- Method: TopLeftGripMorph>>borderOffset (in category 'private') -----
- borderOffset
- |width|
- width :=SystemWindow borderWidth +1.
- ^self handleOrigin + width asPoint!

Item was added:
+ ----- Method: TopLeftGripMorph>>drawOn: (in category 'drawing') -----
+ drawOn: aCanvas
+
+ super drawOn: aCanvas.
+
+ self showHandle ifTrue: [
+ aCanvas
+ fillRoundRect: ((self topLeft + self handleInset asPoint extent: self class gripThickness @ self height) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor).
+ aCanvas
+ fillRoundRect: ((self topLeft + self handleInset asPoint extent: self width @ self class gripThickness) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor).
+
+
+ ].!

Item was removed:
- ----- Method: TopLeftGripMorph>>handleOrigin (in category 'private') -----
- handleOrigin
- ^25@25!

Item was changed:
  ----- Method: TopLeftGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct new bounds at this time."
+ self topLeft: owner topLeft.!
- layoutProportionallyIn: newBounds
- | b |
- b := owner bounds.
- self bounds: (b topLeft extent: self extent)
- !

Item was changed:
+ ----- Method: TopLeftGripMorph>>ptName (in category 'accessing') -----
- ----- Method: TopLeftGripMorph>>ptName (in category 'target resize') -----
  ptName
  ^#topLeft!

Item was changed:
  ----- Method: TopRightGripMorph>>apply: (in category 'target resize') -----
  apply: delta
  | oldBounds |
+ oldBounds := self target bounds.
+ self target
- oldBounds := target bounds.
- target
  bounds: (oldBounds origin + (0@delta y) corner: oldBounds corner + (delta x @ 0))!

Item was removed:
- ----- Method: TopRightGripMorph>>borderOffset (in category 'private') -----
- borderOffset
- |width|
- width :=SystemWindow borderWidth +1 .
- ^self handleOrigin + ( width negated @ (width) )!

Item was added:
+ ----- Method: TopRightGripMorph>>drawOn: (in category 'drawing') -----
+ drawOn: aCanvas
+
+ super drawOn: aCanvas.
+
+ self showHandle ifTrue: [
+ aCanvas
+ fillRoundRect: ((self topRight + ((self handleInset negated + self class gripThickness negated) @ self handleInset) extent: self class gripThickness @ self height) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor).
+ aCanvas
+ fillRoundRect: ((self topLeft + (self handleInset negated @ self handleInset) extent: self width @ self class gripThickness) insetBy: self handleInset)
+ radius: 3
+ fillStyle: (SolidFillStyle color: self handleColor).]!

Item was changed:
  ----- Method: TopRightGripMorph>>gripLayoutFrame (in category 'accessing') -----
  gripLayoutFrame
  ^ LayoutFrame
  fractions: (1 @ 0 corner: 1 @ 0)
+ offsets: (0 @ 0 corner: 0 @ 0)!
- offsets:  (0 @ 0 corner: 0 @ 0)!

Item was removed:
- ----- Method: TopRightGripMorph>>handleOrigin (in category 'private') -----
- handleOrigin
- ^0@25!

Item was changed:
  ----- Method: TopRightGripMorph>>layoutProportionallyIn: (in category 'layout') -----
+ layoutProportionallyIn: cellBounds
+
+ self flag: #workaround. "mt: We cannot know that our owner has always the correct new bounds at this time."
+ self topRight: owner topRight.!
- layoutProportionallyIn: newBounds
- | b |
- b := owner bounds.
-
- self bounds: (b right - self width @ b top extent: self extent)
- !

Item was changed:
+ (PackageInfo named: 'Morphic') postscript: '"Migrate all open resizers."
+ AbstractResizerMorph allSubInstancesDo: [:ea |
+ ea handleColor isColor ifFalse: [ea handleColor: nil].
+ ea removeAllMorphs].
+
+ "Re-enable deprecation warnings in Trunk."
+ Deprecation showDeprecationWarnings: true.'!
- (PackageInfo named: 'Morphic') postscript: 'SmalltalkEditor initializeShiftCmdKeyShortcuts'!