Class: Fox::FXApp

Inherits:
Object
  • Object
show all
Defined in:
lib/fox16/input.rb,
lib/fox16/chore.rb,
lib/fox16/signal.rb,
lib/fox16/timeout.rb,
lib/fox16/aliases.rb,
lib/fox16/iterators.rb

Instance Method Summary collapse

Instance Method Details

#addChore(*args, &block) ⇒ Object

Add a idle processing message to be sent to a target object when the system becomes idle, i.e. when there are no more events to be processed. There are several forms for #addChore; the original form (from FOX) takes two arguments, a target object and a message identifier:

app.addChore(tgt, sel)

If a chore with the same target and message already exists, it will be rescheduled.

A second form takes a Method instance as its single argument:

app.addChore(mthd)

For this form, the method should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form takes a block:

app.addChore() do |sender, sel, data|
    ... handle the chore ...
end

All of these return a reference to an opaque FXChore instance that can be passed to #removeChore if it is necessary to remove the chore before it fires.

For the last two forms, you can pass in the optional :repeat parameter to cause the chore to be re-registered after it fires, e.g.

chore = app.addChore(:repeat => true) do |sender, sel, data|
    ... handle the chore ...
    ... re-add the chore ...
end


46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
# File 'lib/fox16/chore.rb', line 46

def addChore(*args, &block)
  params = {}
  params = args.pop if args.last.is_a? Hash
  tgt, sel = nil, 0
  if args.length > 0
    if args[0].respond_to? :call
      tgt = params[:target] || FXPseudoTarget.new
      tgt.pconnect(SEL_CHORE, args[0], params)
    else
      tgt, sel = args[0], args[1]
    end
  else
    tgt = params[:target] || FXPseudoTarget.new
    tgt.pconnect(SEL_CHORE, block, params)
  end
  addChoreOrig(tgt, sel)
  params[:target] = tgt
  params[:selector] = sel
  params
end

#addChoreOrigObject

:nodoc:



5
# File 'lib/fox16/chore.rb', line 5

alias addChoreOrig		addChore

#addDeadline(due, *args, &block) ⇒ Object

Add deadline timeout message to be sent when the due time is reached. This is the preferred way to schedule regularly occuring events, as the exact time of issue will not suffer increasing errors as with the addTimeout() method. However, it is important to ensure that the due time is sufficiently far into the future, as otherwise the system may be swamped executing nothing but timeout messages.

There are several forms for #addDeadline; the original form takes three arguments:

timeout = app.addDeadline(due, tgt, sel)

Here, due is the due time (a Time instance) for this timeout. The second and third arguments are the target object and message identifier for the message to be sent when this deadline is reached.

A second form of #addDeadline takes a Method instance as its single argument:

timeout = app.addDeadline(due, mthd)

For this form, the method should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form of #addDeadline takes a block:

timeout = app.addDeadline(due) do |sender, sel, data|
    ... handle the timeout ...
end

All of these return a reference to an opaque object (actually, a hash) that can be passed to #removeTimeout if it is necessary to remove the timeout before it fires.

Raises:

  • (ArgumentError)


111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
# File 'lib/fox16/timeout.rb', line 111

def addDeadline(due, *args, &block)
  raise ArgumentError, "due time should be a Time instance" unless due.is_a? Time
  params = {}
  params = args.pop if args.last.is_a? Hash
  params[:due] = due
  tgt, sel = nil, 0
  if args.length > 0
    if args[0].respond_to? :call
      tgt = params[:target] || FXPseudoTarget.new
      tgt.pconnect(SEL_TIMEOUT, args[0], params)
    else # it's some other kind of object
      tgt = args[0]
      sel = args[1]
    end
  else
    tgt = params[:target] || FXPseudoTarget.new
    tgt.pconnect(SEL_TIMEOUT, block, params)
  end
  addDeadlineOrig(tgt, sel, due.to_f*1000000000) # convert seconds to nanoseconds
  params[:target] = tgt
  params[:selector] = sel
  params
end

#addDeadlineOrigObject

:nodoc:



6
# File 'lib/fox16/timeout.rb', line 6

alias addDeadlineOrig	addDeadline

#addInput(fd, mode, *args, &block) ⇒ Object

Add a file descriptor fileDesc to be watched for activity as determined by mode, where mode is a bitwise OR (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT). A message of type SEL_IO_READ, SEL_IO_WRITE, or SEL_IO_EXCEPT will be sent to the target when the specified activity is detected on the file descriptor.

There are several forms for #addInput; the original form (from FOX) takes four arguments:

anApp.addInput(fileDesc, mode, anObject, aMessageId)

A second form takes three arguments:

anApp.addInput(fileDesc, mode, aMethod)

For this form, aMethod should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form of #addInput takes a block:

anApp.addInput(fileDesc, mode) { |sender, sel, data|
  ... handle the I/O event ...
}


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# File 'lib/fox16/input.rb', line 34

def addInput(fd, mode, *args, &block)
  params = {}
  params = args.pop if args.last.is_a? Hash
  tgt, sel = nil, 0
  if args.length > 0
    if args[0].respond_to? :call
      tgt = FXPseudoTarget.new
      tgt.pconnect(SEL_IO_READ, args[0], params)
      tgt.pconnect(SEL_IO_WRITE, args[0], params)
      tgt.pconnect(SEL_IO_EXCEPT, args[0], params)
    else # it's some other kind of object
      tgt = args[0]
      sel = args[1]
    end
  else
    tgt = FXPseudoTarget.new
    tgt.pconnect(SEL_IO_READ, block, params)
    tgt.pconnect(SEL_IO_WRITE, block, params)
    tgt.pconnect(SEL_IO_EXCEPT, block, params)
  end
  addInputOrig(tgt, sel, fd, mode, ptr)
end

#addInputOrigObject

:nodoc:



5
# File 'lib/fox16/input.rb', line 5

alias addInputOrig addInput

#addSignal(sig, *args, &block) ⇒ Object

Register a signal processing message to be sent to target object when the specified signal is raised.

There are several forms for #addSignal; the original form (from FOX) takes (up to) five arguments:

anApp.addSignal(aSignal, anObject, aMessageId, sendImmediately=false, flags=0)

Here, aSignal is a string indicating the operating system signal of interest (such as “SIGINT”). The second and third arguments are the target object and message identifier for the message to be sent when this signal is raised. If sendImmediately is true, the message will be sent to the target right away; this should be used with extreme care as the application is interrupted at an unknown point in its execution. The flags are to be set as per POSIX definitions.

A second form of #addSignal takes a Method instance as its second argument:

anApp.addSignal(aSignal, aMethod, sendImmediately=false, flags=0)

For this form, the method should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form of #addSignal takes a block:

anApp.addSignal(aSignal, sendImmediately=false, flags=0) { |sender, sel, data|
  ... handle the signal ...
}


41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
# File 'lib/fox16/signal.rb', line 41

def addSignal(sig, *args, &block)
  params = {}
  params = args.pop if args.last.is_a? Hash
  tgt, sel, immediate, flags = nil, 0, false, 0
  if args.length > 0
    if args[0].respond_to? :call
      tgt = FXPseudoTarget.new
      tgt.pconnect(SEL_SIGNAL, args[0], params)
      immediate = (args.length > 1) ? args[1] : false
      flags = (args.length > 2) ? args[2] : 0
    elsif (args[0].kind_of? TrueClass) || (args[0].kind_of? FalseClass)
      tgt = FXPseudoTarget.new
      tgt.pconnect(SEL_SIGNAL, block, params)
      immediate = args[0]
      flags = (args.length > 1) ? args[1] : 0
    else # it's some other kind of object
      tgt = args[0]
      sel = (args.length > 1) ? args[1] : 0
      immediate = (args.length > 2) ? args[2] : false
      flags = (args.length > 3) ? args[3] : 0
    end
  else
    tgt = FXPseudoTarget.new
    tgt.pconnect(SEL_SIGNAL, block, params)
  end
  addSignalOrig(sig, tgt, sel, immediate, flags)
end

#addSignalOrigObject

:nodoc:



5
# File 'lib/fox16/signal.rb', line 5

alias addSignalOrig addSignal

#addTimeout(ms, *args, &block) ⇒ Object

Add a timeout message to be sent to target object in ms milliseconds. By default, the timer fires only once after the interval expires. The last argument is optional user data which will be passed along as the ptr argument of the message handler. If a timer with the same target and message already exists, it will be rescheduled.

There are several forms for #addTimeout; the original form (from FOX) takes three arguments:

timeout = app.addTimeout(delay, tgt, sel)

Here, delay is the time interval (in milliseconds) to wait before firing this timeout. The second and third arguments are the target object and message identifier for the message to be sent when this timeout fires.

A second form of #addTimeout takes a Method instance as its single argument:

timeout = app.addTimeout(delay, mthd)

For this form, the method should have the standard argument list for a FOX message handler. That is, the method should take three arguments, for the message sender (an FXObject), the message selector, and the message data (if any).

The last form of #addTimeout takes a block:

timeout = app.addTimeout(delay) do |sender, sel, data|
    ... handle the timeout ...
end

All of these return a reference to an opaque object (actually, a hash) that can be passed to #removeTimeout if it is necessary to remove the timeout before it fires.

For the last two forms, you can pass in the optional :repeat parameter to cause the timeout to be re-registered after it fires, e.g.

timeout = app.addTimeout(delay, :repeat => true) do |sender, sel, data|
    ... handle the timeout ...
    ... re-add the timeout with the same delay ...
end


55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
# File 'lib/fox16/timeout.rb', line 55

def addTimeout(ms, *args, &block)
  params = {}
  params = args.pop if args.last.is_a? Hash
  params[:delay] = ms
  tgt, sel = nil, 0
  if args.length > 0
    if args[0].respond_to? :call
      tgt = params[:target] || FXPseudoTarget.new
      tgt.pconnect(SEL_TIMEOUT, args[0], params)
    else # it's some other kind of object
      tgt = args[0]
      sel = args[1]
    end
  else
    tgt = params[:target] || FXPseudoTarget.new
    tgt.pconnect(SEL_TIMEOUT, block, params)
  end
  ns = 1000*ms # FOX expects timeout value in nanoseconds
  addTimeoutOrig(tgt, sel, ns)
  params[:target] = tgt
  params[:selector] = sel
  params
end

#addTimeoutOrigObject

:nodoc:



5
# File 'lib/fox16/timeout.rb', line 5

alias addTimeoutOrig	addTimeout

#animSpeed(*args) ⇒ Object

:nodoc:



198
199
200
# File 'lib/fox16/aliases.rb', line 198

def animSpeed(*args) # :nodoc:
  getAnimSpeed(*args)
end

#animSpeed=(*args) ⇒ Object

:nodoc:



201
202
203
# File 'lib/fox16/aliases.rb', line 201

def animSpeed=(*args) # :nodoc:
  setAnimSpeed(*args)
end

#appName(*args) ⇒ Object

:nodoc:



114
115
116
# File 'lib/fox16/aliases.rb', line 114

def appName(*args) # :nodoc:
  getAppName(*args)
end

#argcObject

:nodoc:



123
124
125
# File 'lib/fox16/aliases.rb', line 123

def argc() # :nodoc:
  getArgc()
end

#argvObject

:nodoc:



126
127
128
# File 'lib/fox16/aliases.rb', line 126

def argv() # :nodoc:
  getArgv()
end

#backColor(*args) ⇒ Object

:nodoc:



258
259
260
# File 'lib/fox16/aliases.rb', line 258

def backColor(*args) # :nodoc:
  getBackColor(*args)
end

#backColor=(*args) ⇒ Object

:nodoc:



261
262
263
# File 'lib/fox16/aliases.rb', line 261

def backColor=(*args) # :nodoc:
  setBackColor(*args)
end

#baseColor(*args) ⇒ Object

:nodoc:



240
241
242
# File 'lib/fox16/aliases.rb', line 240

def baseColor(*args) # :nodoc:
  getBaseColor(*args)
end

#baseColor=(*args) ⇒ Object

:nodoc:



243
244
245
# File 'lib/fox16/aliases.rb', line 243

def baseColor=(*args) # :nodoc:
  setBaseColor(*args)
end

#beginWaitCursorObject

Changes the default application cursor to an hourglass shape, to provide a visual cue to the user that it's time to wait. To revert the default application cursor to its normal shape, call the #endWaitCursor method. For example,

getApp().beginWaitCursor()
  ... time-consuming operation ...
getApp().endWaitCursor()

Invocations of #beginWaitCursor may be nested, and if so, the call to #endWaitCursor is matched with the most recent call to #beginWaitCursor.

If an optional code block is provided, #endWaitCursor is automatically called after the block terminates, e.g.

getApp().beginWaitCursor() {
          ... time-consuming operation ...
  ... endWaitCursor() is called automatically ...
}


366
367
368
369
370
371
372
373
374
375
# File 'lib/fox16/iterators.rb', line 366

def beginWaitCursor
  beginWaitCursor0
  if block_given?
    begin
  	  yield
  	ensure
  	  endWaitCursor
  	end
  end
end

#beginWaitCursor0Object

:nodoc:



342
# File 'lib/fox16/iterators.rb', line 342

alias beginWaitCursor0 beginWaitCursor

#blinkSpeed(*args) ⇒ Object

:nodoc:



192
193
194
# File 'lib/fox16/aliases.rb', line 192

def blinkSpeed(*args) # :nodoc:
  getBlinkSpeed(*args)
end

#blinkSpeed=(*args) ⇒ Object

:nodoc:



195
196
197
# File 'lib/fox16/aliases.rb', line 195

def blinkSpeed=(*args) # :nodoc:
  setBlinkSpeed(*args)
end

#borderColor(*args) ⇒ Object

:nodoc:



234
235
236
# File 'lib/fox16/aliases.rb', line 234

def borderColor(*args) # :nodoc:
  getBorderColor(*args)
end

#borderColor=(*args) ⇒ Object

:nodoc:



237
238
239
# File 'lib/fox16/aliases.rb', line 237

def borderColor=(*args) # :nodoc:
  setBorderColor(*args)
end

#clickSpeed(*args) ⇒ Object

:nodoc:



174
175
176
# File 'lib/fox16/aliases.rb', line 174

def clickSpeed(*args) # :nodoc:
  getClickSpeed(*args)
end

#clickSpeed=(*args) ⇒ Object

:nodoc:



177
178
179
# File 'lib/fox16/aliases.rb', line 177

def clickSpeed=(*args) # :nodoc:
  setClickSpeed(*args)
end

#cursorWindow(*args) ⇒ Object

:nodoc:



147
148
149
# File 'lib/fox16/aliases.rb', line 147

def cursorWindow(*args) # :nodoc:
  getCursorWindow(*args)
end

#defaultVisual(*args) ⇒ Object

:nodoc:



132
133
134
# File 'lib/fox16/aliases.rb', line 132

def defaultVisual(*args) # :nodoc:
  getDefaultVisual(*args)
end

#defaultVisual=(*args) ⇒ Object

:nodoc:



135
136
137
# File 'lib/fox16/aliases.rb', line 135

def defaultVisual=(*args) # :nodoc:
  setDefaultVisual(*args)
end

#disableThreadsObject

:nodoc:



315
316
317
# File 'lib/fox16/aliases.rb', line 315

def disableThreads # :nodoc:
  self.threadsEnabled = false
end

#displayObject

:nodoc:



129
130
131
# File 'lib/fox16/aliases.rb', line 129

def display # :nodoc:
  getDisplay()
end

#dragDelta(*args) ⇒ Object

:nodoc:



222
223
224
# File 'lib/fox16/aliases.rb', line 222

def dragDelta(*args) # :nodoc:
  getDragDelta(*args)
end

#dragDelta=(*args) ⇒ Object

:nodoc:



225
226
227
# File 'lib/fox16/aliases.rb', line 225

def dragDelta=(*args) # :nodoc:
  setDragDelta(*args)
end

#dragWindowObject

:nodoc:



153
154
155
# File 'lib/fox16/aliases.rb', line 153

def dragWindow # :nodoc:
  getDragWindow
end

#enableThreadsObject

:nodoc:



312
313
314
# File 'lib/fox16/aliases.rb', line 312

def enableThreads # :nodoc:
  self.threadsEnabled = true
end

#foreColor(*args) ⇒ Object

:nodoc:



264
265
266
# File 'lib/fox16/aliases.rb', line 264

def foreColor(*args) # :nodoc:
  getForeColor(*args)
end

#foreColor=(*args) ⇒ Object

:nodoc:



267
268
269
# File 'lib/fox16/aliases.rb', line 267

def foreColor=(*args) # :nodoc:
  setForeColor(*args)
end

#hasChore?(*args) ⇒ Boolean

Return true if given chore has been set, otherwise return false.

For example, you might set up a chore at some point in the execution:

chore = app.addChore { ... }

but decide that you want to “cancel” that chore later (before it's had a chance to run):

if app.hasChore?(chore)
  app.removeChore(chore)
end

Returns:

  • (Boolean)


94
95
96
97
98
99
100
101
# File 'lib/fox16/chore.rb', line 94

def hasChore?(*args)
  if args.length == 2
    hasChoreOrig?(args[0], args[1])
  else
    hsh = args[0]
    hasChoreOrig?(hsh[:target], hsh[:selector])
  end
end

#hasChoreOrig?Object

:nodoc:



7
# File 'lib/fox16/chore.rb', line 7

alias hasChoreOrig?		hasChore?

#hasTimeout?(*args) ⇒ Boolean

Return true if given timeout has been set, otherwise return false.

For example, suppose you set up a timeout event to run ten seconds from now:

timeout = app.addTimeout(10*1000, ...)

but in the meantime, you decide that you want to cancel it if it hasn't run yet:

if app.hasTimeout?(timeout)
  app.removeTimeout(timeout)
end

Returns:

  • (Boolean)


164
165
166
167
168
169
170
171
# File 'lib/fox16/timeout.rb', line 164

def hasTimeout?(*args)
  if args.length == 2
    hasTimeoutOrig?(args[0], args[1])
  else
    hsh = args[0]
    hasTimeoutOrig?(hsh[:target], hsh[:selector])
  end
end

#hasTimeoutOrig?Object

:nodoc:



8
# File 'lib/fox16/timeout.rb', line 8

alias hasTimeoutOrig?	hasTimeout?

#hiliteColor(*args) ⇒ Object

:nodoc:



246
247
248
# File 'lib/fox16/aliases.rb', line 246

def hiliteColor(*args) # :nodoc:
  getHiliteColor(*args)
end

#hiliteColor=(*args) ⇒ Object

:nodoc:



249
250
251
# File 'lib/fox16/aliases.rb', line 249

def hiliteColor=(*args) # :nodoc:
  setHiliteColor(*args)
end

#initialized?Boolean

:nodoc:

Returns:

  • (Boolean)


120
121
122
# File 'lib/fox16/aliases.rb', line 120

def initialized? # :nodoc:
  isInitialized()
end

#mainloopObject

:nodoc:



111
112
113
# File 'lib/fox16/aliases.rb', line 111

def mainloop # :nodoc:
  run
end

:nodoc:



204
205
206
# File 'lib/fox16/aliases.rb', line 204

def menuPause(*args) # :nodoc:
  getMenuPause(*args)
end

:nodoc:



207
208
209
# File 'lib/fox16/aliases.rb', line 207

def menuPause=(*args) # :nodoc:
  setMenuPause(*args)
end

#modal?(*args) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean)


150
151
152
# File 'lib/fox16/aliases.rb', line 150

def modal?(*args) # :nodoc:
  isModal(*args)
end

#monoVisual(*args) ⇒ Object

:nodoc:



138
139
140
# File 'lib/fox16/aliases.rb', line 138

def monoVisual(*args) # :nodoc:
  getMonoVisual(*args)
end

#normalFont(*args) ⇒ Object

:nodoc:



156
157
158
# File 'lib/fox16/aliases.rb', line 156

def normalFont(*args) # :nodoc:
  getNormalFont(*args)
end

#normalFont=(*args) ⇒ Object

:nodoc:



159
160
161
# File 'lib/fox16/aliases.rb', line 159

def normalFont=(*args) # :nodoc:
  setNormalFont(*args)
end

#remainingTimeout(*args) ⇒ Object

Return the time remaining (in milliseconds) until the given timer fires. If the timer is past due, zero is returned. If there is no such timer, infinity (UINT_MAX) is returned.

For example:

timeout = app.addTimeout(ms, ...)
time_left = app.remainingTimeout(timeout)


183
184
185
186
187
188
189
190
191
192
# File 'lib/fox16/timeout.rb', line 183

def remainingTimeout(*args)
  ns  = nil
  if args.length == 2
    ns = remainingTimeoutOrig(args[0], args[1])
  else
    hsh = args[0]
    ns = remainingTimeoutOrig(hsh[:target], hsh[:selector])
  end
  ms = ns/1000 # FOX returns the time in nanoseconds
end

#remainingTimeoutOrigObject

:nodoc:



9
# File 'lib/fox16/timeout.rb', line 9

alias remainingTimeoutOrig	remainingTimeout

#removeChore(*args) ⇒ Object

Remove idle processing message identified by tgt and sel. See the documentation for #hasChore? for an example of how to use the #removeChore method.



72
73
74
75
76
77
78
79
# File 'lib/fox16/chore.rb', line 72

def removeChore(*args)
  if args.length == 2
    removeChoreOrig(args[0], args[1])
  else
    params = args[0]
    removeChoreOrig(params[:target], params[:selector])
  end
end

#removeChoreOrigObject

:nodoc:



6
# File 'lib/fox16/chore.rb', line 6

alias removeChoreOrig	removeChore

#removeTimeout(*args) ⇒ Object

Remove timeout previously registered using #addDeadline or #addTimeout; returns nil. For an example of how to use #removeTimeout, see the documentation for the #hasTimeout? method.



140
141
142
143
144
145
146
147
# File 'lib/fox16/timeout.rb', line 140

def removeTimeout(*args)
  if args.length == 2
    removeTimeoutOrig(args[0], args[1])
  else
    params = args[0]
    removeTimeoutOrig(params[:target], params[:selector])
  end
end

#removeTimeoutOrigObject

:nodoc:



7
# File 'lib/fox16/timeout.rb', line 7

alias removeTimeoutOrig	removeTimeout

#rootWindow(*args) ⇒ Object

:nodoc:



141
142
143
# File 'lib/fox16/aliases.rb', line 141

def rootWindow(*args) # :nodoc:
  getRootWindow(*args)
end

#rootWindow=(*args) ⇒ Object

:nodoc:



144
145
146
# File 'lib/fox16/aliases.rb', line 144

def rootWindow=(*args) # :nodoc:
  setRootWindow(*args)
end

#scrollDelay(*args) ⇒ Object

:nodoc:



186
187
188
# File 'lib/fox16/aliases.rb', line 186

def scrollDelay(*args) # :nodoc:
  getScrollDelay(*args)
end

#scrollDelay=(*args) ⇒ Object

:nodoc:



189
190
191
# File 'lib/fox16/aliases.rb', line 189

def scrollDelay=(*args) # :nodoc:
  setScrollDelay(*args)
end

#scrollSpeed(*args) ⇒ Object

:nodoc:



180
181
182
# File 'lib/fox16/aliases.rb', line 180

def scrollSpeed(*args) # :nodoc:
  getScrollSpeed(*args)
end

#scrollSpeed=(*args) ⇒ Object

:nodoc:



183
184
185
# File 'lib/fox16/aliases.rb', line 183

def scrollSpeed=(*args) # :nodoc:
  setScrollSpeed(*args)
end

#selbackColor(*args) ⇒ Object

:nodoc:



276
277
278
# File 'lib/fox16/aliases.rb', line 276

def selbackColor(*args) # :nodoc:
  getSelbackColor(*args)
end

#selbackColor=(*args) ⇒ Object

:nodoc:



279
280
281
# File 'lib/fox16/aliases.rb', line 279

def selbackColor=(*args) # :nodoc:
  setSelbackColor(*args)
end

#selforeColor(*args) ⇒ Object

:nodoc:



270
271
272
# File 'lib/fox16/aliases.rb', line 270

def selforeColor(*args) # :nodoc:
  getSelforeColor(*args)
end

#selforeColor=(*args) ⇒ Object

:nodoc:



273
274
275
# File 'lib/fox16/aliases.rb', line 273

def selforeColor=(*args) # :nodoc:
  setSelforeColor(*args)
end

#selMenuBackColor(*args) ⇒ Object

:nodoc:



303
304
305
# File 'lib/fox16/aliases.rb', line 303

def selMenuBackColor(*args) # :nodoc:
  getSelMenuBackColor(*args)
end

#selMenuBackColor=(*args) ⇒ Object

:nodoc:



300
301
302
# File 'lib/fox16/aliases.rb', line 300

def selMenuBackColor=(*args) # :nodoc:
  setSelMenuBackColor(*args)
end

#selMenuTextColor(*args) ⇒ Object

:nodoc:



297
298
299
# File 'lib/fox16/aliases.rb', line 297

def selMenuTextColor(*args) # :nodoc:
  getSelMenuTextColor(*args)
end

#selMenuTextColor=(*args) ⇒ Object

:nodoc:



294
295
296
# File 'lib/fox16/aliases.rb', line 294

def selMenuTextColor=(*args) # :nodoc:
  setSelMenuTextColor(*args)
end

#shadowColor(*args) ⇒ Object

:nodoc:



252
253
254
# File 'lib/fox16/aliases.rb', line 252

def shadowColor(*args) # :nodoc:
  getShadowColor(*args)
end

#shadowColor=(*args) ⇒ Object

:nodoc:



255
256
257
# File 'lib/fox16/aliases.rb', line 255

def shadowColor=(*args) # :nodoc:
  setShadowColor(*args)
end

#sleepTime(*args) ⇒ Object

:nodoc:



306
307
308
# File 'lib/fox16/aliases.rb', line 306

def sleepTime(*args) # :nodoc:
  getSleepTime(*args)
end

#sleepTime=(*args) ⇒ Object

:nodoc:



309
310
311
# File 'lib/fox16/aliases.rb', line 309

def sleepTime=(*args) # :nodoc:
  setSleepTime(*args)
end

#tipbackColor(*args) ⇒ Object

:nodoc:



288
289
290
# File 'lib/fox16/aliases.rb', line 288

def tipbackColor(*args) # :nodoc:
  getTipbackColor(*args)
end

#tipbackColor=(*args) ⇒ Object

:nodoc:



291
292
293
# File 'lib/fox16/aliases.rb', line 291

def tipbackColor=(*args) # :nodoc:
  setTipbackColor(*args)
end

#tipforeColor(*args) ⇒ Object

:nodoc:



282
283
284
# File 'lib/fox16/aliases.rb', line 282

def tipforeColor(*args) # :nodoc:
  getTipforeColor(*args)
end

#tipforeColor=(*args) ⇒ Object

:nodoc:



285
286
287
# File 'lib/fox16/aliases.rb', line 285

def tipforeColor=(*args) # :nodoc:
  setTipforeColor(*args)
end

#tooltipPauseObject

:nodoc:



210
211
212
# File 'lib/fox16/aliases.rb', line 210

def tooltipPause # :nodoc:
  getTooltipPause()
end

#tooltipPause=(*args) ⇒ Object

:nodoc:



213
214
215
# File 'lib/fox16/aliases.rb', line 213

def tooltipPause=(*args) # :nodoc:
  setTooltipPause(*args)
end

#tooltipTime(*args) ⇒ Object

:nodoc:



216
217
218
# File 'lib/fox16/aliases.rb', line 216

def tooltipTime(*args) # :nodoc:
  getTooltipTime(*args)
end

#tooltipTime=(*args) ⇒ Object

:nodoc:



219
220
221
# File 'lib/fox16/aliases.rb', line 219

def tooltipTime=(*args) # :nodoc:
  setTooltipTime(*args)
end

#translatorObject

:nodoc:



321
322
323
# File 'lib/fox16/aliases.rb', line 321

def translator # :nodoc:
  getTranslator()
end

#translator=(*args) ⇒ Object

:nodoc:



318
319
320
# File 'lib/fox16/aliases.rb', line 318

def translator=(*args) # :nodoc:
  setTranslator(*args)
end

#typingSpeed(*args) ⇒ Object

:nodoc:



168
169
170
# File 'lib/fox16/aliases.rb', line 168

def typingSpeed(*args) # :nodoc:
  getTypingSpeed(*args)
end

#typingSpeed=(*args) ⇒ Object

:nodoc:



171
172
173
# File 'lib/fox16/aliases.rb', line 171

def typingSpeed=(*args) # :nodoc:
  setTypingSpeed(*args)
end

#vendorName(*args) ⇒ Object

:nodoc:



117
118
119
# File 'lib/fox16/aliases.rb', line 117

def vendorName(*args) # :nodoc:
  getVendorName(*args)
end

#waitCursor(*args) ⇒ Object

:nodoc:



162
163
164
# File 'lib/fox16/aliases.rb', line 162

def waitCursor(*args) # :nodoc:
  getWaitCursor(*args)
end

#waitCursor=(*args) ⇒ Object

:nodoc:



165
166
167
# File 'lib/fox16/aliases.rb', line 165

def waitCursor=(*args) # :nodoc:
  setWaitCursor(*args)
end

#wheelLines(*args) ⇒ Object

:nodoc:



228
229
230
# File 'lib/fox16/aliases.rb', line 228

def wheelLines(*args) # :nodoc:
  getWheelLines(*args)
end

#wheelLines=(*args) ⇒ Object

:nodoc:



231
232
233
# File 'lib/fox16/aliases.rb', line 231

def wheelLines=(*args) # :nodoc:
  setWheelLines(*args)
end

#windowCountObject

:nodoc:



324
325
326
# File 'lib/fox16/aliases.rb', line 324

def windowCount # :nodoc:
  getWindowCount()
end