[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[sc-dev] cross-platform gui wrappers - draft
Very early draft, to be precise.
I thought I would get a jump on making some wrappers for the SC gui
objects. I wrote some code last night to generate class definitions
for all the SCViews that would mimic each one's interface, and then
started on some manual cleanups.
The basic idea is that each class has a method, *viewSourceClass, to
indicate which "real" GUI object to use. So, right now I'm using
SCWindow, SCButton etc., but if I wanted to use SwingOSC instead, I
could just replace all the viewSourceClass-es to be JSCWindow,
JSCButton etc. For SCUM, you could put the scum classes into
viewSourceClass, and the cocoa-based methods in the wrappers would
translate the behaviors into the scum interface.
For cocoa, the mimicking methods just pass the message on to the base view.
Not done yet:
- most of the methods return ^view.myMethod, but many of the
corresponding source class methods returns "this" -- that's bad
because in the case of variable assignment, then you end up talking to
the real object instead of the wrapper. Setters are fixed but not
things like SCWindow-closed (which do an action and then return
"this").
- there are probably a bunch of redundant methods in these definitions.
- I want to move all the *viewSourceClass methods into a separate file
to make it simpler to switch between cocoa and SwingOSC.
Other comments? I wanted to ask before spending a huge amount of time on it.
hjh
PS Sorry it isn't an .sc file--I was doing a little cleanup at work
(naughty boy).
--
James Harkins /// dewdrop world
jamshark70@xxxxxxxxxxxxxxxxx
http://www.dewdrop-world.net
"Come said the Muse,
Sing me a song no poet has yet chanted,
Sing me the universal." -- Whitman
GUIWrapper : SCViewHolder {
*new { |parent, bounds| ^super.new.view_(this.viewSourceClass.new(parent, bounds)) }
}
GUIWindow : GUIWrapper {
*viewSourceClass { ^SCWindow }
*allWindows { ^this.viewSourceClass.allWindows }
*allWindows_ { |allWindows| this.viewSourceClass.allWindows_(allWindows) }
*new { |name = "panel", bounds, resizable = true, border = true|
^super.new.view_(this.viewSourceClass.new(name, bounds, resizable, border))
}
*closeAll { ^this.viewSourceClass.closeAll }
*screenBounds { ^this.viewSourceClass.screenBounds }
*prGetScreenBounds { |argBounds| ^this.viewSourceClass.prGetScreenBounds(argBounds) }
*viewPalette { ^this.viewSourceClass.viewPalette }
name { ^view.name }
onClose { ^view.onClose }
onClose_ { |onClose| view.onClose_(onClose) }
view { ^view.view }
userCanClose { ^view.userCanClose }
alwaysOnTop { ^view.alwaysOnTop }
drawHook { ^view.drawHook }
drawHook_ { |drawHook| view.drawHook_(drawHook) }
acceptsMouseOver { ^view.acceptsMouseOver }
initSCWindow { |argName, argBounds, resizable, border|
^view.initSCWindow(argName, argBounds, resizable, border)
}
asView { ^view.asView }
add { |aView| ^view.add(aView) }
close { ^view.close }
closed { ^view.closed }
isClosed { ^view.isClosed }
fullScreen { ^view.fullScreen }
endFullScreen { ^view.endFullScreen }
userCanClose_ { |boo| view.userCanClose_(boo) }
acceptsMouseOver_ { |bool| view.acceptsMouseOver_(bool) }
front { ^view.front }
alwaysOnTop_ { |boolean = true| view.alwaysOnTop_(boolean) }
prSetAlwaysOnTop { |boolean = true| ^view.prSetAlwaysOnTop(boolean) }
refresh { ^view.refresh }
minimize { ^view.minimize }
alpha_ { |alpha| view.alpha_(alpha) }
name_ { |argName| view.name_(argName) }
bounds_ { |argBounds| view.bounds_(argBounds) }
setInnerExtent { |w, h| ^view.setInnerExtent(w, h) }
bounds { ^view.bounds }
play { |function| ^view.play(function) }
findByID { |id| ^view.findByID(id) }
prInit { |argName, argBounds, resizable, border|
^view.prInit(argName, argBounds, resizable, border)
}
prClose { ^view.prClose }
prSetName { |argName| ^view.prSetName(argName) }
prGetBounds { |argBounds| ^view.prGetBounds(argBounds) }
prSetBounds { |argBounds| ^view.prSetBounds(argBounds) }
prSetAcceptMouseOver { |bool| ^view.prSetAcceptMouseOver(bool) }
callDrawHook { ^view.callDrawHook }
flow { |func, bounds| ^view.flow(func, bounds) }
asPageLayout { |title, bounds| ^view.asPageLayout(title, bounds) }
asFlowView { |bounds| ^view.asFlowView(bounds) }
}
GUIView : GUIWrapper {
*viewSourceClass { ^SCView }
*currentDrag { ^this.viewSourceClass.currentDrag }
*currentDrag_ { |currentDrag| this.viewSourceClass.currentDrag_(currentDrag) }
*currentDragString { ^this.viewSourceClass.currentDragString }
*currentDragString_ { |currentDragString|
this.viewSourceClass.currentDragString_(currentDragString)
}
*globalKeyDownAction { ^this.viewSourceClass.globalKeyDownAction }
*globalKeyDownAction_ { |globalKeyDownAction|
this.viewSourceClass.globalKeyDownAction_(globalKeyDownAction)
}
*globalKeyUpAction { ^this.viewSourceClass.globalKeyUpAction }
*globalKeyUpAction_ { |globalKeyUpAction|
this.viewSourceClass.globalKeyUpAction_(globalKeyUpAction)
}
*viewClass { ^this.viewSourceClass.viewClass }
*paletteExample { |parent, bounds| ^this.viewSourceClass.paletteExample(parent, bounds) }
*importDrag { ^this.viewSourceClass.importDrag }
parent { ^view.parent }
action { ^view.action }
action_ { |action| view.action_(action) }
background { ^view.background }
mouseDownAction { ^view.mouseDownAction }
mouseDownAction_ { |mouseDownAction| view.mouseDownAction_(mouseDownAction) }
mouseUpAction { ^view.mouseUpAction }
mouseUpAction_ { |mouseUpAction| view.mouseUpAction_(mouseUpAction) }
mouseOverAction { ^view.mouseOverAction }
mouseOverAction_ { |mouseOverAction| view.mouseOverAction_(mouseOverAction) }
mouseMoveAction { ^view.mouseMoveAction }
mouseMoveAction_ { |mouseMoveAction| view.mouseMoveAction_(mouseMoveAction) }
keyDownAction { ^view.keyDownAction }
keyDownAction_ { |keyDownAction| view.keyDownAction_(keyDownAction) }
keyUpAction { ^view.keyUpAction }
keyUpAction_ { |keyUpAction| view.keyUpAction_(keyUpAction) }
keyTyped { ^view.keyTyped }
keyTyped_ { |keyTyped| view.keyTyped_(keyTyped) }
beginDragAction { ^view.beginDragAction }
beginDragAction_ { |beginDragAction| view.beginDragAction_(beginDragAction) }
canReceiveDragHandler { ^view.canReceiveDragHandler }
canReceiveDragHandler_ { |canReceiveDragHandler|
view.canReceiveDragHandler_(canReceiveDragHandler)
}
receiveDragHandler { ^view.receiveDragHandler }
receiveDragHandler_ { |receiveDragHandler| view.receiveDragHandler_(receiveDragHandler) }
onClose { ^view.onClose }
onClose_ { |onClose| view.onClose_(onClose) }
init { |argParent, argBounds| ^view.init(argParent, argBounds) }
asView { ^view.asView }
bounds { ^view.bounds }
bounds_ { |rect| view.bounds_(rect) }
visible { ^view.visible }
visible_ { |bool| view.visible_(bool) }
enabled { ^view.enabled }
enabled_ { |bool| view.enabled_(bool) }
canFocus { ^view.canFocus }
canFocus_ { |bool| view.canFocus_(bool) }
focus { |flag = true| ^view.focus(flag) }
hasFocus { ^view.hasFocus }
id { ^view.id }
id_ { |id| view.id_(id) }
refresh { ^view.refresh }
findByID { |id| ^view.findByID(id) }
isClosed { ^view.isClosed }
notClosed { ^view.notClosed }
remove { ^view.remove }
resize { ^view.resize }
resize_ { |resize| view.resize_(resize) }
background_ { |color| view.background_(color) }
mouseDown { |x, y, modifiers, buttonNumber, clickCount|
^view.mouseDown(x, y, modifiers, buttonNumber, clickCount)
}
mouseUp { |x, y, modifiers| ^view.mouseUp(x, y, modifiers) }
mouseMove { |x, y, modifiers| ^view.mouseMove(x, y, modifiers) }
mouseOver { |x, y| ^view.mouseOver(x, y) }
keyDown { |char, modifiers, unicode, keycode|
^view.keyDown(char, modifiers, unicode, keycode)
}
defaultKeyDownAction { |key, modifiers, unicode, keycode|
^view.defaultKeyDownAction(key, modifiers, unicode, keycode)
}
handleKeyDownBubbling { |view, char, modifiers, unicode, keycode|
^view.handleKeyDownBubbling(view, char, modifiers, unicode, keycode)
}
keyUp { |char, modifiers, unicode, keycode| ^view.keyUp(char, modifiers, unicode, keycode) }
defaultKeyUpAction { |key, modifiers, unicode, keycode|
^view.defaultKeyUpAction(key, modifiers, unicode, keycode)
}
handleKeyUpBubbling { |view, char, modifiers, unicode, keycode|
^view.handleKeyUpBubbling(view, char, modifiers, unicode, keycode)
}
beginDrag { ^view.beginDrag }
defaultGetDrag { ^view.defaultGetDrag }
canReceiveDrag { ^view.canReceiveDrag }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
receiveDrag { ^view.receiveDrag }
getParents { ^view.getParents }
doAction { ^view.doAction }
properties { ^view.properties }
getPropertyList { ^view.getPropertyList }
setPropertyList { |list| ^view.setPropertyList(list) }
prInit { |argParent, argBounds, argViewClass|
^view.prInit(argParent, argBounds, argViewClass)
}
prClose { ^view.prClose }
prRemove { ^view.prRemove }
setProperty { |key, value| ^view.setProperty(key, value) }
getProperty { |key, value| ^view.getProperty(key, value) }
setPropertyWithAction { |symbol, obj| ^view.setPropertyWithAction(symbol, obj) }
recursiveResize { ^view.recursiveResize }
findRightBottom { ^view.findRightBottom }
isActive { ^view.isActive }
backColor_ { |color| view.backColor_(color) }
}
GUITabletView : GUIView {
*viewSourceClass { ^SCTabletView }
mouseDown { |x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation|
^view.mouseDown(x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation)
}
mouseUp { |x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation|
^view.mouseUp(x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation)
}
doAction { |x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation|
^view.doAction(x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation)
}
}
GUIScope : GUIView {
*viewSourceClass { ^SCScope }
bufnum { ^view.bufnum }
bufnum_ { |num| view.bufnum_(num) }
x { ^view.x }
x_ { |val| view.x_(val) }
y { ^view.y }
y_ { |val| view.y_(val) }
xZoom { ^view.xZoom }
xZoom_ { |val| view.xZoom_(val) }
yZoom { ^view.yZoom }
yZoom_ { |val| view.yZoom_(val) }
gridColor { ^view.gridColor }
gridColor_ { |color| view.gridColor_(color) }
waveColors { ^view.waveColors }
waveColors_ { |arrayOfColors| view.waveColors_(arrayOfColors) }
style_ { |val| view.style_(val) }
properties { ^view.properties }
}
GUISoundFileView : GUIView {
*viewSourceClass { ^SCSoundFileView }
soundfile { ^view.soundfile }
metaAction { ^view.metaAction }
metaAction_ { |metaAction| view.metaAction_(metaAction) }
elasticMode { ^view.elasticMode }
drawsWaveForm { ^view.drawsWaveForm }
readProgress { ^view.readProgress }
startFrame { ^view.startFrame }
numFrames { ^view.numFrames }
dataFrames { ^view.dataFrames }
dataFrames_ { |dataFrames| view.dataFrames_(dataFrames) }
viewFrames { ^view.viewFrames }
scrollPos { ^view.scrollPos }
block { ^view.block }
block_ { |block| view.block_(block) }
init { |argParent, argBounds| ^view.init(argParent, argBounds) }
soundfile_ { |snd| view.soundfile_(snd) }
read { |startframe = 0, frames = 0, block = 64, closeFile = true|
^view.read(startframe, frames, block, closeFile)
}
readWithTask { |startframe = 0, frames, block = 64, doneAction, showProgress = true|
^view.readWithTask(startframe, frames, block, doneAction, showProgress)
}
makeProgressWindow { ^view.makeProgressWindow }
readFileWithTask { |soundfile, startframe = 0, frames, block = 64, doneAction, showProgress = true|
^view.readFileWithTask(soundfile, startframe, frames, block, doneAction, showProgress)
}
readFile { |asoundfile, startframe = 0, frames = 0, block = 0, closefile = true|
^view.readFile(asoundfile, startframe, frames, block, closefile)
}
mouseEndTrack { |x, y| ^view.mouseEndTrack(x, y) }
doMetaAction { ^view.doMetaAction }
currentSelection_ { |index| view.currentSelection_(index) }
currentSelection { ^view.currentSelection }
setSelectionStart { |index, frame| ^view.setSelectionStart(index, frame) }
setSelectionSize { |index, frame| ^view.setSelectionSize(index, frame) }
setEditableSelectionStart { |index, bool| ^view.setEditableSelectionStart(index, bool) }
setEditableSelectionSize { |index, bool| ^view.setEditableSelectionSize(index, bool) }
setSelectionColor { |index, color| ^view.setSelectionColor(index, color) }
selections { ^view.selections }
selectionStart { |index| ^view.selectionStart(index) }
selectionSize { |index| ^view.selectionSize(index) }
selectionStartTime { |index| ^view.selectionStartTime(index) }
selectionDuration { |index| ^view.selectionDuration(index) }
readSelection { ^view.readSelection }
readSelectionWithTask { ^view.readSelectionWithTask }
gridOn_ { |boolean| view.gridOn_(boolean) }
gridResolution_ { |resolution| view.gridResolution_(resolution) }
dataNumSamples { ^view.dataNumSamples }
data { ^view.data }
data_ { |arr| view.data_(arr) }
setData { |arr, block = 64, startframe = 0, channels = 1, samplerate = 44100|
^view.setData(arr, block, startframe, channels, samplerate)
}
elasticMode_ { |mode| view.elasticMode_(mode) }
drawsWaveForm_ { |bool| view.drawsWaveForm_(bool) }
timeCursorPosition_ { |frame| view.timeCursorPosition_(frame) }
timeCursorOn_ { |bool| view.timeCursorOn_(bool) }
timeCursorColor_ { |color| view.timeCursorColor_(color) }
zoom { |factor| ^view.zoom(factor) }
zoomToFrac { |frac| ^view.zoomToFrac(frac) }
zoomAllOut { ^view.zoomAllOut }
zoomSelection { |index| ^view.zoomSelection(index) }
scrollTo { |position| ^view.scrollTo(position) }
scroll { |amount| ^view.scroll(amount) }
scrollToStart { ^view.scrollToStart }
scrollToEnd { ^view.scrollToEnd }
selectAll { |index| ^view.selectAll(index) }
selectNone { |index| ^view.selectNone(index) }
gridOffset_ { |offset| view.gridOffset_(offset) }
updateScroll { ^view.updateScroll }
updateData { ^view.updateData }
}
GUIMovieView : GUIView {
*viewSourceClass { ^SCMovieView }
rate { ^view.rate }
loopMode { ^view.loopMode }
muted { ^view.muted }
path { ^view.path }
editable { ^view.editable }
start { ^view.start }
stop { ^view.stop }
path_ { |moviePath| view.path_(moviePath) }
muted_ { |bool| view.muted_(bool) }
playSelectionOnly_ { |bool| view.playSelectionOnly_(bool) }
rate_ { |ratein| view.rate_(ratein) }
loopMode_ { |mode| view.loopMode_(mode) }
gotoEnd { ^view.gotoEnd }
stepForward { ^view.stepForward }
stepBack { ^view.stepBack }
gotoBeginning { ^view.gotoBeginning }
currentTime_ { |time| view.currentTime_(time) }
currentTime { ^view.currentTime }
editable_ { |bool| view.editable_(bool) }
showControllerAndAdjustSize { |show, adjust| ^view.showControllerAndAdjustSize(show, adjust) }
resizeWithMagnification { |size| ^view.resizeWithMagnification(size) }
copy { ^view.copy }
clear { ^view.clear }
cut { ^view.cut }
paste { ^view.paste }
}
GUITextView : GUIView {
*viewSourceClass { ^SCTextView }
mouseDownAction { ^view.mouseDownAction }
mouseDownAction_ { |mouseDownAction| view.mouseDownAction_(mouseDownAction) }
stringColor { ^view.stringColor }
font { ^view.font }
editable { ^view.editable }
autohidesScrollers { ^view.autohidesScrollers }
hasHorizontalScroller { ^view.hasHorizontalScroller }
hasVerticalScroller { ^view.hasVerticalScroller }
textBounds { ^view.textBounds }
usesTabToFocusNextView { ^view.usesTabToFocusNextView }
enterInterpretsSelection { ^view.enterInterpretsSelection }
mouseDown { |clickPos| ^view.mouseDown(clickPos) }
string { ^view.string }
string_ { |str| view.string_(str) }
selectedString { ^view.selectedString }
selectedString_ { |str| view.selectedString_(str) }
selectionStart { ^view.selectionStart }
selectionSize { ^view.selectionSize }
stringColor_ { |color| view.stringColor_(color) }
setStringColor { |color, rangeStart = -1, rangeSize = 0|
^view.setStringColor(color, rangeStart, rangeSize)
}
font_ { |afont| view.font_(afont) }
setFont { |font, rangestart = -1, rangesize = 0| ^view.setFont(font, rangestart, rangesize) }
setString { |string, rangestart = 0, rangesize = 0|
^view.setString(string, rangestart, rangesize)
}
editable_ { |bool| view.editable_(bool) }
enabled_ { |bool| view.enabled_(bool) }
usesTabToFocusNextView_ { |bool| view.usesTabToFocusNextView_(bool) }
enterInterpretsSelection_ { |bool| view.enterInterpretsSelection_(bool) }
autohidesScrollers_ { |bool| view.autohidesScrollers_(bool) }
hasHorizontalScroller_ { |bool| view.hasHorizontalScroller_(bool) }
hasVerticalScroller_ { |bool| view.hasVerticalScroller_(bool) }
textBounds_ { |rect| view.textBounds_(rect) }
}
GUIMultiSliderView : GUIView {
*viewSourceClass { ^SCMultiSliderView }
metaAction { ^view.metaAction }
metaAction_ { |metaAction| view.metaAction_(metaAction) }
size { ^view.size }
size_ { |size| view.size_(size) }
gap { ^view.gap }
editable { ^view.editable }
elasticMode { ^view.elasticMode }
draw { ^view.draw }
mouseBeginTrack { |x, y, modifiers| ^view.mouseBeginTrack(x, y, modifiers) }
mouseTrack { |x, y, modifiers| ^view.mouseTrack(x, y, modifiers) }
mouseEndTrack { |x, y, modifiers| ^view.mouseEndTrack(x, y, modifiers) }
properties { ^view.properties }
elasticMode_ { |mode| view.elasticMode_(mode) }
step_ { |stepSize| view.step_(stepSize) }
step { ^view.step }
value { ^view.value }
value_ { |val| view.value_(val) }
reference { ^view.reference }
reference_ { |val| view.reference_(val) }
index { ^view.index }
index_ { |inx| view.index_(inx) }
isFilled_ { |abool| view.isFilled_(abool) }
xOffset_ { |aval| view.xOffset_(aval) }
gap_ { |inx| view.gap_(inx) }
selectionSize { ^view.selectionSize }
selectionSize_ { |aval| view.selectionSize_(aval) }
currentvalue { ^view.currentvalue }
fillColor_ { |acolor| view.fillColor_(acolor) }
strokeColor_ { |acolor| view.strokeColor_(acolor) }
colors_ { |strokec, fillc| view.colors_(strokec, fillc) }
currentvalue_ { |iny| view.currentvalue_(iny) }
showIndex_ { |abool| view.showIndex_(abool) }
drawLines { |abool| ^view.drawLines(abool) }
drawLines_ { |abool| view.drawLines_(abool) }
drawRects_ { |abool| view.drawRects_(abool) }
readOnly_ { |val| view.readOnly_(val) }
editable_ { |val| view.editable_(val) }
thumbSize_ { |val| view.thumbSize_(val) }
indexThumbSize_ { |val| view.indexThumbSize_(val) }
valueThumbSize_ { |val| view.valueThumbSize_(val) }
indexIsHorizontal_ { |val| view.indexIsHorizontal_(val) }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
defaultGetDrag { ^view.defaultGetDrag }
doMetaAction { ^view.doMetaAction }
}
GUIEnvelopeView : GUIView {
*viewSourceClass { ^SCEnvelopeView }
allConnections { ^view.allConnections }
allConnections_ { |allConnections| view.allConnections_(allConnections) }
items { ^view.items }
items_ { |items| view.items_(items) }
fixedSelection { ^view.fixedSelection }
value_ { |val| view.value_(val) }
setString { |index, astring| ^view.setString(index, astring) }
strings_ { |astrings| view.strings_(astrings) }
value { ^view.value }
setThumbHeight { |index, height| ^view.setThumbHeight(index, height) }
thumbHeight_ { |height| view.thumbHeight_(height) }
setThumbWidth { |index, width| ^view.setThumbWidth(index, width) }
thumbWidth_ { |width| view.thumbWidth_(width) }
setThumbSize { |index, size| ^view.setThumbSize(index, size) }
thumbSize_ { |size| view.thumbSize_(size) }
setFillColor { |index, color| ^view.setFillColor(index, color) }
fillColor_ { |color| view.fillColor_(color) }
connect { |from, aconnections| ^view.connect(from, aconnections) }
select { |index| ^view.select(index) }
selectIndex { |index| ^view.selectIndex(index) }
x { ^view.x }
y { ^view.y }
x_ { |ax| view.x_(ax) }
y_ { |ay| view.y_(ay) }
index { ^view.index }
lastIndex { ^view.lastIndex }
setEditable { |index, boolean| ^view.setEditable(index, boolean) }
editable_ { |boolean| view.editable_(boolean) }
selectionColor_ { |acolor| view.selectionColor_(acolor) }
defaultGetDrag { ^view.defaultGetDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
addValue { |xval, yval| ^view.addValue(xval, yval) }
fixedSelection_ { |bool| view.fixedSelection_(bool) }
}
GUIEnvelopeEdit : GUIView {
*viewSourceClass { ^SCEnvelopeEdit }
// *viewClass {
// ^this.viewSourceClass.viewClass
// }
*new { |parent, bounds, env, pointsPerSegment = 10|
^super.new.view_(this.viewSourceClass.new(parent, bounds, env, pointsPerSegment))
}
env { ^view.env }
pointsPerSegment { ^view.pointsPerSegment }
minLevel { ^view.minLevel }
maxLevel { ^view.maxLevel }
minTime { ^view.minTime }
maxTime { ^view.maxTime }
initSCEnvelopeEdit { |argEnv, argPPS| ^view.initSCEnvelopeEdit(argEnv, argPPS) }
redraw { ^view.redraw }
refresh { ^view.refresh }
updateAll { ^view.updateAll }
updateSegment { |segNum| ^view.updateSegment(segNum) }
minLevel_ { |level| view.minLevel_(level) }
maxLevel_ { |level| view.maxLevel_(level) }
minTime_ { |sec| view.minTime_(sec) }
maxTime_ { |sec| view.maxTime_(sec) }
}
GUIUserView : GUIView {
*viewSourceClass { ^SCUserView }
keyDownFunc { ^view.keyDownFunc }
keyDownFunc_ { |keyDownFunc| view.keyDownFunc_(keyDownFunc) }
drawFunc { ^view.drawFunc }
drawFunc_ { |drawFunc| view.drawFunc_(drawFunc) }
mouseBeginTrackFunc { ^view.mouseBeginTrackFunc }
mouseBeginTrackFunc_ { |mouseBeginTrackFunc| view.mouseBeginTrackFunc_(mouseBeginTrackFunc) }
mouseTrackFunc { ^view.mouseTrackFunc }
mouseTrackFunc_ { |mouseTrackFunc| view.mouseTrackFunc_(mouseTrackFunc) }
mouseEndTrackFunc { ^view.mouseEndTrackFunc }
mouseEndTrackFunc_ { |mouseEndTrackFunc| view.mouseEndTrackFunc_(mouseEndTrackFunc) }
draw { ^view.draw }
mouseBeginTrack { |x, y, modifiers| ^view.mouseBeginTrack(x, y, modifiers) }
mouseTrack { |x, y, modifiers| ^view.mouseTrack(x, y, modifiers) }
mouseEndTrack { |x, y, modifiers| ^view.mouseEndTrack(x, y, modifiers) }
keyDown { |key, modifiers, unicode| ^view.keyDown(key, modifiers, unicode) }
}
GUIStaticTextBase : GUIView {
*viewSourceClass { ^SCStaticTextBase }
string { ^view.string }
font { ^view.font }
object { ^view.object }
setBoth { ^view.setBoth }
setBoth_ { |setBoth| view.setBoth_(setBoth) }
font_ { |argFont| view.font_(argFont) }
string_ { |argString| view.string_(argString) }
align_ { |align| view.align_(align) }
stringColor { ^view.stringColor }
stringColor_ { |color| view.stringColor_(color) }
object_ { |obj| view.object_(obj) }
properties { ^view.properties }
}
GUIDragView : GUIView {
*viewSourceClass { ^SCDragView }
defaultGetDrag { ^view.defaultGetDrag }
silentObject_ { |obj| view.silentObject_(obj) }
}
GUIDragSink : GUIView {
*viewSourceClass { ^SCDragSink }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
}
GUIDragBoth : GUIView {
*viewSourceClass { ^SCDragBoth }
defaultGetDrag { ^view.defaultGetDrag }
}
GUIDragSource : GUIView {
*viewSourceClass { ^SCDragSource }
}
GUINumberBox : GUIView {
*viewSourceClass { ^SCNumberBox }
keyString { ^view.keyString }
keyString_ { |keyString| view.keyString_(keyString) }
step { ^view.step }
step_ { |step| view.step_(step) }
typingColor { ^view.typingColor }
typingColor_ { |typingColor| view.typingColor_(typingColor) }
normalColor { ^view.normalColor }
normalColor_ { |normalColor| view.normalColor_(normalColor) }
init { |argParent, argBounds| ^view.init(argParent, argBounds) }
increment { ^view.increment }
decrement { ^view.decrement }
value { ^view.value }
value_ { |val| view.value_(val) }
valueAction_ { |val| view.valueAction_(val) }
boxColor { ^view.boxColor }
boxColor_ { |color| view.boxColor_(color) }
properties { ^view.properties }
defaultGetDrag { ^view.defaultGetDrag }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
}
GUITextField : GUIView {
*viewSourceClass { ^SCTextField }
// *viewClass {
// ^this.viewSourceClass.viewClass
// }
string_ { |s| view.string_(s) }
}
GUIStaticText : GUIView {
*viewSourceClass { ^SCStaticText }
}
GUICXAbstractLabel : GUIView {
*viewSourceClass { ^CXAbstractLabel }
*new { |layout, string, x, y = 17, minWidth = 15|
^super.new.view_(this.viewSourceClass.new(layout, string, x, y, minWidth))
}
label_ { |string| view.label_(string) }
bold { ^view.bold }
}
GUIArgNameLabel : GUIView {
*viewSourceClass { ^ArgNameLabel }
*new { |name, layout, minWidth = 130|
^super.new.view_(this.viewSourceClass.new(name, layout, minWidth))
}
}
GUIVariableNameLabel : GUIView {
*viewSourceClass { ^VariableNameLabel }
*new { |name, layout, minWidth = 120|
^super.new.view_(this.viewSourceClass.new(name, layout, minWidth))
}
}
GUICXLabel : GUIView {
*viewSourceClass { ^CXLabel }
*bgcolor { ^this.viewSourceClass.bgcolor }
*bgcolor_ { |bgcolor| this.viewSourceClass.bgcolor_(bgcolor) }
*new { |layout, string, x, y = 17, minWidth = 15|
^super.new.view_(this.viewSourceClass.new(layout, string, x, y, minWidth))
}
}
GUIControlView : GUIView {
*viewSourceClass { ^SCControlView }
}
GUIListView : GUIView {
*viewSourceClass { ^SCListView }
font { ^view.font }
items { ^view.items }
enterKeyAction { ^view.enterKeyAction }
enterKeyAction_ { |enterKeyAction| view.enterKeyAction_(enterKeyAction) }
item { ^view.item }
value { ^view.value }
value_ { |val| view.value_(val) }
valueAction_ { |val| view.valueAction_(val) }
font_ { |argFont| view.font_(argFont) }
items_ { |array| view.items_(array) }
stringColor { ^view.stringColor }
stringColor_ { |color| view.stringColor_(color) }
selectedStringColor { ^view.selectedStringColor }
selectedStringColor_ { |color| view.selectedStringColor_(color) }
hiliteColor { ^view.hiliteColor }
hiliteColor_ { |color| view.hiliteColor_(color) }
properties { ^view.properties }
defaultGetDrag { ^view.defaultGetDrag }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
}
GUIPopUpMenu : GUIView {
*viewSourceClass { ^SCPopUpMenu }
font { ^view.font }
items { ^view.items }
value { ^view.value }
value_ { |val| view.value_(val) }
valueAction_ { |val| view.valueAction_(val) }
font_ { |argFont| view.font_(argFont) }
items_ { |array| view.items_(array) }
stringColor { ^view.stringColor }
stringColor_ { |color| view.stringColor_(color) }
properties { ^view.properties }
defaultGetDrag { ^view.defaultGetDrag }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
}
GUIButton : GUIView {
*viewSourceClass { ^SCButton }
font { ^view.font }
states { ^view.states }
value { ^view.value }
value_ { |val| view.value_(val) }
valueAction_ { |val| view.valueAction_(val) }
doAction { |modifiers| ^view.doAction(modifiers) }
font_ { |argFont| view.font_(argFont) }
states_ { |array| view.states_(array) }
properties { ^view.properties }
defaultGetDrag { ^view.defaultGetDrag }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
}
GUISliderBase : GUIView {
*viewSourceClass { ^SCSliderBase }
knobColor { ^view.knobColor }
knobColor_ { |color| view.knobColor_(color) }
step_ { |stepSize| view.step_(stepSize) }
step { ^view.step }
properties { ^view.properties }
}
GUI2DSlider : GUIView {
*viewSourceClass { ^SC2DSlider }
x { ^view.x }
x_ { |val| view.x_(val) }
activex_ { |val| view.activex_(val) }
y { ^view.y }
y_ { |val| view.y_(val) }
activey_ { |val| view.activey_(val) }
properties { ^view.properties }
incrementY { ^view.incrementY }
decrementY { ^view.decrementY }
incrementX { ^view.incrementX }
decrementX { ^view.decrementX }
defaultGetDrag { ^view.defaultGetDrag }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
}
GUI2DTabletSlider : GUIView {
*viewSourceClass { ^SC2DTabletSlider }
mouseDown { |x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation| ^view.mouseDown(x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation) }
mouseUp { |x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation| ^view.mouseUp(x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation) }
doAction { |x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation| ^view.doAction(x, y, pressure, tiltx, tilty, deviceID, buttonNumber, clickCount, absoluteZ, rotation) }
}
GUIRangeSlider : GUIView {
*viewSourceClass { ^SCRangeSlider }
lo { ^view.lo }
lo_ { |val| view.lo_(val) }
activeLo_ { |val| view.activeLo_(val) }
hi { ^view.hi }
hi_ { |val| view.hi_(val) }
activeHi_ { |val| view.activeHi_(val) }
range { ^view.range }
range_ { |val| view.range_(val) }
activeRange_ { |val| view.activeRange_(val) }
properties { ^view.properties }
increment { ^view.increment }
decrement { ^view.decrement }
defaultGetDrag { ^view.defaultGetDrag }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
}
GUISlider : GUIView {
*viewSourceClass { ^SCSlider }
value { ^view.value }
value_ { |val| view.value_(val) }
valueAction_ { |val| view.valueAction_(val) }
increment { ^view.increment }
decrement { ^view.decrement }
defaultGetDrag { ^view.defaultGetDrag }
defaultCanReceiveDrag { ^view.defaultCanReceiveDrag }
defaultReceiveDrag { ^view.defaultReceiveDrag }
thumbSize { ^view.thumbSize }
thumbSize_ { |size| view.thumbSize_(size) }
properties { ^view.properties }
}
GUIKnob : GUIView {
*viewSourceClass { ^SCKnob }
}
GUIContainerView : GUIView {
*viewSourceClass { ^SCContainerView }
children { ^view.children }
decorator { ^view.decorator }
decorator_ { |decorator| view.decorator_(decorator) }
add { |child| ^view.add(child) }
removeAll { ^view.removeAll }
prRemoveChild { |child| ^view.prRemoveChild(child) }
prClose { ^view.prClose }
recursiveResize { ^view.recursiveResize }
findRightBottom { ^view.findRightBottom }
flow { |func, bounds| ^view.flow(func, bounds) }
horz { |func, bounds| ^view.horz(func, bounds) }
vert { |func, bounds| ^view.vert(func, bounds) }
comp { |func, bounds| ^view.comp(func, bounds) }
asPageLayout { |title, bounds| ^view.asPageLayout(title, bounds) }
}
GUILayoutView : GUIView {
*viewSourceClass { ^SCLayoutView }
properties { ^view.properties }
spacing { ^view.spacing }
spacing_ { |distance| view.spacing_(distance) }
asFlowView { ^view.asFlowView }
}
GUIFlowView : GUIView {
*viewSourceClass { ^FlowView }
*layout { |f, bounds| ^this.viewSourceClass.layout(f, bounds) }
init { |parent, bounds| ^view.init(parent, bounds) }
reflowAll { ^view.reflowAll }
innerBounds { ^view.innerBounds }
resizeToFit { |reflow = false, tryParent = false| ^view.resizeToFit(reflow, tryParent) }
bounds_ { |b| view.bounds_(b) }
wouldExceedBottom { |aBounds| ^view.wouldExceedBottom(aBounds) }
anyChildExceeds { ^view.anyChildExceeds }
layRight { |x, y| ^view.layRight(x, y) }
startRow { ^view.startRow }
removeOnClose { |updater| ^view.removeOnClose(updater) }
viewDidClose { ^view.viewDidClose }
hr { |color, height = 3, borderStyle = 1| ^view.hr(color, height, borderStyle) }
resizeToFitContents { ^view.resizeToFitContents }
flow { |func, bounds| ^view.flow(func, bounds) }
horz { |func, bounds| ^view.horz(func, bounds) }
vert { |func, bounds| ^view.vert(func, bounds) }
comp { |func, bounds| ^view.comp(func, bounds) }
indentedRemaining { ^view.indentedRemaining }
asFlowView { ^view.asFlowView }
asPageLayout { ^view.asPageLayout }
}
GUIVLayoutView : GUIView {
*viewSourceClass { ^SCVLayoutView }
}
GUIHLayoutView : GUIView {
*viewSourceClass { ^SCHLayoutView }
}
GUICompositeView : GUIView {
*viewSourceClass { ^SCCompositeView }
asFlowView { |bounds| ^view.asFlowView(bounds) }
}
GUITopView : GUIView {
*viewSourceClass { ^SCTopView }
handleKeyDownBubbling { |view, char, modifiers, unicode, keycode| ^view.handleKeyDownBubbling(view, char, modifiers, unicode, keycode) }
handleKeyUpBubbling { |view, char, modifiers, unicode, keycode| ^view.handleKeyUpBubbling(view, char, modifiers, unicode, keycode) }
canReceiveDrag { ^view.canReceiveDrag }
findWindow { ^view.findWindow }
defaultReceiveDrag { ^view.defaultReceiveDrag }
}