HelpSource/Classes/String.schelp

   1 CLASS::String
   2 summary::array of characters
   3 categories:: Collections>Ordered
   4
   5 DESCRIPTION::
   6 String represents an array of characters.
   7
   8 Strings can be written literally using double quotes:
   9 code::
  10 "my string".class.postln;
  11 ::
  12
  13 CLASSMETHODS::
  14
  15 private::initClass
  16 private::doUnixCmdAction
  17 private::unixCmdActions
  18
  19 method::readNew
  20 Read the entire contents of a link::Classes/File:: and return them as a new String.
  21
  22 method::scDir
  23 Return the base resource directory of SuperCollider.
  24
  25 INSTANCEMETHODS::
  26
  27 private::prUnixCmd, prFormat, prCat, prBounds, hash, species, getSCDir, prDrawInRect, prDrawAtPoint
  28
  29 subsection:: Accessing characters
  30
  31 method::@
  32 method::at
  33 Strings respond to .at in a manner similar to other indexed collections. Each element is a link::Classes/Char::.
  34 code::
  35 "ABCDEFG".at(2).postln;
  36 ::
  37
  38 method::ascii
  39 Returns an Array of asci numbers of the Strings's characters.
  40 code::
  41 "wertvoll".ascii;
  42 ::
  43
  44 subsection:: Comparing strings
  45
  46 method::compare
  47 Returns a -1, 0, or 1 depending on whether the receiver should be sorted before the argument, is equal to the argument or should be sorted after the argument. This is a case sensitive compare.
  48
  49 method::<
  50 Returns a link::Classes/Boolean:: whether the receiver should be sorted before the argument.
  51
  52 method::>
  53 Returns a link::Classes/Boolean:: whether the receiver should be sorted after the argument.
  54
  55 method::==
  56 Returns a link::Classes/Boolean:: whether the two Strings are equal.
  57
  58 method::!=
  59 Returns a link::Classes/Boolean:: whether the two Strings are not equal.
  60
  61 subsection:: Posting strings
  62
  63 method::post
  64 Prints the string to the current post window.
  65
  66 method::postln
  67 Prints the string and a carriage return to the current post window.
  68
  69 method::postc, postcln
  70 As link::#-post:: and link::#-postln::, but formatted as a comment.
  71 code::
  72 "This is a comment.".postcln;
  73 ::
  74
  75 method::postf
  76 Prints a formatted string with arguments to the current post window. The % character in the format string is replaced by a string representation of an argument. To print a % character use \\% .
  77 code::
  78 postf("this % a %. pi = %, list = %\n", "is", "test", pi.round(1e-4), (1..4))
  79
  80 this is a test. pi = 3.1416, list = [ 1, 2, 3, 4 ]
  81 ::
  82
  83 method::postcs
  84 As link::#-postln::, but posts the link::#-asCompileString#compileString:: of the reciever.
  85 code::
  86 List[1, 2, ["comment", [3, 2]], { 1.0.rand }].postcs;
  87 ::
  88
  89 method::error
  90 Prepends an error banner and posts the string.
  91 ::
  92
  93 method::warn
  94 Prepends a warning banner and posts the string.
  95
  96 method::inform
  97 Posts the string.
  98
  99 subsection:: Interpreting strings as code
 100
 101 method::compile
 102 Compiles a String containing legal SuperCollider code and returns a Function.
 103 code::
 104 (
 105 var f;
 106 f = "2 + 1".compile.postln;
 107 f.value.postln;
 108 )
 109 ::
 110
 111 method::interpret
 112 Compile and execute a String containing legal SuperCollider code, returning the result.
 113 code::
 114 "2 + 1".interpret.postln;
 115 ::
 116
 117 method::interpretPrint
 118 Compile, execute and print the result of a String containing legal SuperCollider code.
 119 code::
 120 "2 + 1".interpretPrint;
 121 ::
 122
 123 subsection:: Converting strings
 124
 125 method::asCompileString
 126 Returns a String formatted for compiling.
 127 code::
 128 (
 129 var f;
 130 f = "myString";
 131 f.postln;
 132 f.asCompileString.postln;
 133 )
 134 ::
 135
 136 method::asSymbol
 137 Return a link::Classes/Symbol:: derived from the String.
 138 code::
 139 (
 140 var z;
 141 z = "myString".asSymbol.postln;
 142 z.class.postln;
 143 )
 144 ::
 145
 146 method::asInteger
 147 Return an link::Classes/Integer:: derived from the String. Strings beginning with non-numeric characters return 0.
 148 code::
 149 "4".asInteger.postln;
 150 ::
 151
 152 method::asFloat
 153 Return a link::Classes/Float:: derived from the String. Strings beginning with non-numeric characters return 0.
 154 code::
 155 "4.3".asFloat.postln;
 156 ::
 157
 158 method::asSecs
 159 Return a link::Classes/Float:: based on converting a time string in format (dd):hh:mm:ss.s. This is the inverse method to link::Classes/SimpleNumber#-asTimeString::.
 160 code::
 161 (45296.asTimeString).asSecs;
 162 "32.1".asSecs;
 163 "62.1".asSecs;          // warns
 164 "0:0:59.9".asSecs;
 165 "1:1:1.1".asSecs;
 166 "-1".asSecs;            // neg sign supported
 167 "-12:34:56".asSecs;
 168 "12:-34:56".asSecs;     // warns
 169 "-23:12.3456".asSecs;   //
 170 "-1:00:00:00".asSecs;   // days too.
 171 ::
 172
 173 subsection:: Concatenate strings
 174
 175 method::++
 176 Return a concatenation of the two strings.
 177 ::
 178
 179 method::+
 180 Return a concatenation of the two strings with a space between them.
 181
 182 method::+/+
 183 Path concatenation operator - useful for avoiding doubling-up slashes unnecessarily.
 184 code::"foo"+/+"bar":: returns code::"foo/bar"::
 185
 186 method::catArgs
 187 Concatenate this string with the following args.
 188 code::
 189 "These are some args: ".catArgs(\fish, SinOsc.ar, {4 + 3}).postln;
 190 ::
 191
 192 method::scatArgs
 193 Same as link::#-catArgs::, but with spaces in between.
 194 code::
 195 "These are some args: ".scatArgs(\fish, SinOsc.ar, {4 + 3}).postln;
 196 ::
 197
 198 method::ccatArgs
 199 Same as link::#-catArgs::, but with commas in between.
 200 code::
 201 "a String".ccatArgs(\fish, SinOsc.ar, {4 + 3}).postln;
 202 ::
 203
 204 method::catList, scatList, ccatList
 205 As link::#-catArgs::, link::#-scatArgs:: and link::#-ccatArgs:: above, but takes a Collection (usually a link::Classes/List:: or an link::Classes/Array::) as an argument.
 206 code::
 207 "a String".ccatList([\fish, SinOsc.ar, {4 + 3}]).postln;
 208 ::
 209
 210
 211
 212 subsection:: Regular expressions
 213
 214 method::matchRegexp
 215 POSIX regular expression matching. Returns true if the receiver (a regular expression pattern) matches the string passed to it. The strong::start:: is an offset where to start searching in the string (default: 0), strong::end:: where to stop.
 216 code::
 217 "c".matchRegexp("abcdefg", 2, 5); // true
 218 "c".matchRegexp("abcdefg", 4, 5); // false
 219
 220 "behaviou?r".matchRegexp("behavior"); // true
 221 "behaviou?r".matchRegexp("behaviour"); // true
 222 "behaviou?r".matchRegexp("behavir"); // false
 223 "b.h.v.r".matchRegexp("behavor"); // true
 224 "b.h.vi*r".matchRegexp("behaviiiiir"); // true
 225 "(a|u)nd".matchRegexp("und"); // true
 226 "(a|u)nd".matchRegexp("and"); // true
 227 "[a-c]nd".matchRegexp("ind"); // false
 228 "[a-c]nd".matchRegexp("bnd"); // true
 229 ::
 230
 231 method::findRegexp
 232 POSIX regular expression search.
 233 code::
 234 "foobar".findRegexp("o*bar");
 235 "32424 334 /**aaaaaa*/".findRegexp("/\\*\\*a*\\*/");
 236 "foobar".findRegexp("(o*)(bar)");
 237 "aaaabaaa".findAllRegexp("a+");
 238 ::
 239
 240
 241 subsection:: Searching strings
 242
 243 method::find
 244 Returns the index of the string in the receiver, or nil if not found. If strong::ignoreCase:: is true, find makes no difference between uppercase and lowercase letters. The strong::offset:: is the point in the string where the search begins.
 245 code::
 246 "These are several words".find("are").postln;
 247 "These are several words".find("fish").postln;
 248 ::
 249
 250 method::findBackwards
 251 Same like link::#-find::, but starts at the end of the string.
 252 code::
 253 // compare:
 254 "These words are several words".find("words"); // 6
 255 "These words are several words".findBackwards("words"); // 24
 256 ::
 257
 258 method::findAll
 259 Returns the indices of the string in the receiver, or nil if not found.
 260 code::
 261 "These are several words which are fish".findAll("are").postln;
 262 "These are several words which are fish".findAll("fish").postln;
 263 ::
 264
 265 method::contains
 266 Returns a link::Classes/Boolean:: indicating if the String contains string.
 267 code::
 268 "These are several words".contains("are").postln;
 269 "These are several words".contains("fish").postln;
 270 ::
 271
 272 method::containsi
 273 Same as link::#-contains::, but case insensitive.
 274 code::
 275 "These are several words".containsi("ArE").postln;
 276 ::
 277
 278 method::containsStringAt
 279 Returns a link::Classes/Boolean:: indicating if the String contains string beginning at the specified index.
 280 code::
 281 "These are several words".containsStringAt(6, "are").postln;
 282 ::
 283
 284 method::icontainsStringAt
 285 Same as link::#-containsStringAt::, but case insensitive.
 286
 287 method::beginsWith
 288 method::endsWith
 289 Returns true if this string begins/ends with the specified other string.
 290 argument:: string
 291 The other string
 292 returns::
 293 A link::Classes/Boolean::
 294
 295 subsection:: Manipulating strings
 296
 297 method::escapeChar
 298 Add the escape character (\) before any character of your choice.
 299 code::
 300 // escape spaces:
 301 "This will become a Unix friendly string".escapeChar($ ).postln;
 302 ::
 303
 304 method::shellQuote
 305 Return a new string suitable for use as a filename in a shell command, by enclosing it in single quotes ( teletype::':: ).
 306 If the string contains any single quotes they will be escaped.
 307 discussion::
 308 You should use this method on a path before embedding it in a string executed by link::#-unixCmd:: or link::#-systemCmd::.
 309 code::
 310 unixCmd("ls"+Platform.userExtensionDir.shellQuote)
 311 ::
 312 note::
 313 This works well with shells such as strong::bash::, other shells might need different quotation/escaping.
 314 ::
 315
 316 method::quote
 317 Return this string enclosed in double-quote ( teletype::":: ) characters.
 318
 319 method::tr
 320 Transliteration. Replace all instances of strong::from:: with strong::to::.
 321 code::
 322 ":-(:-(:-(".tr($(, $)); //turn the frowns upside down
 323 ::
 324
 325 method::replace
 326 Like link::#-tr::, but with strings as arguments.
 327 code::
 328 "Here are several words which are fish".replace("are", "were");
 329 ::
 330
 331 method::format
 332 Returns a formatted string with arguments. The % character in the format string is replaced by a string representation of an argument. To print a % character use \\% .
 333 code::
 334 format("this % a %. pi = %, list = %\n", "is", "test", pi.round(1e-4), (1..4))
 335
 336 this is a test. pi = 3.1416, list = [ 1, 2, 3, 4 ]
 337 ::
 338
 339
 340 method::padLeft
 341 method::padRight
 342 Pad this string with strong::string:: so it fills strong::size:: character.
 343 argument:: size
 344 Number of characters to fill
 345 argument:: string
 346 Padding string
 347
 348 method::toUpper
 349 Return this string with uppercase letters.
 350
 351 method::toLower
 352 Return this string with lowercase letters.
 353
 354 method::stripRTF
 355 Returns a new String with all RTF formatting removed.
 356 code::
 357 (
 358 // same as File-readAllStringRTF
 359 g = File("/code/SuperCollider3/build/Help/UGens/Chaos/HenonC.help.rtf","r");
 360 g.readAllString.stripRTF.postln;
 361 g.close;
 362 )
 363 ::
 364
 365 method::split
 366 Returns an Array of Strings split at the separator. The separator is a link::Classes/Char::, and is not included in the output array. The default separator is $/, handy for Unix paths.
 367 code::
 368 "This/could/be/a/Unix/path".split.postln;
 369 "These are several words".split($ ).postln;
 370 ::
 371
 372 subsection:: Stream support
 373
 374 method::printOn
 375 Print the String on stream.
 376 code::
 377 "Print this on Post".printOn(Post);
 378
 379 // equivalent to:
 380 Post << "Print this on Post";
 381 ::
 382
 383 method::storeOn
 384 Same as link::#-printOn::, but formatted link::#-asCompileString::.
 385 code::
 386 "Store this on Post".storeOn(Post);
 387
 388 // equivalent to:
 389 Post <<< "Store this on Post";
 390 ::
 391
 392
 393
 394 subsection::Unix Support
 395
 396 Where relevant, the current working directory is the same as the location of the SuperCollider app and the shell is the Bourne shell (sh). Note that the cwd, and indeed the shell itself, does not persist:
 397 code::
 398 "echo $0".unixCmd; // print the shell (sh)
 399 "pwd".unixCmd;
 400 "cd Help/".unixCmd;
 401 "pwd".unixCmd;
 402
 403 "export FISH=mackerel".unixCmd;
 404 "echo $FISH".unixCmd;
 405 ::
 406 It is however possible to execute complex commands:
 407 code::
 408 "pwd; cd Help/; pwd".unixCmd;
 409 "export FISH=mackerel; echo $FISH".unixCmd;
 410 ::
 411 Also on os x applescript can be called via osascript:
 412 code::
 413 "osascript -e 'tell application \"Safari\" to activate'".unixCmd;
 414 ::
 415 Should you need an environment variable to persist you can use link::#-setenv::.
 416
 417 note::
 418 Despite the fact that the method is called 'unixCmd', strong::it does work in Windows::. The string must be a DOS command, however: "dir" rather than "ls" for instance.
 419 ::
 420
 421 method::unixCmd
 422 Execute a unix command asynchronously using the standard shell (sh).
 423 argument:: action
 424 A link::Classes/Function:: that is called when the process has exited. It is passed two arguments: the exit code and pid of the exited process.
 425 argument:: postOutput
 426 A link::Classes/Boolean:: that controls whether or not the output of the process is displayed in the post window.
 427 returns::
 428 An link::Classes/Integer:: - the pid of the newly created process. Use link::Classes/Integer#-pidRunning:: to test if a process is alive.
 429 discussion::
 430 Example:
 431 code::
 432 "ls Help".unixCmd;
 433 "echo one; sleep 1; echo two; sleep 1".unixCmd { |res, pid| [\done, res, pid].postln };
 434 ::
 435
 436 method::unixCmdGetStdOut
 437 Similar to link::#-unixCmd:: except that the stdout of the process is returned (synchronously) rather than sent to the post window.
 438 code::
 439 ~listing = "ls Help".unixCmdGetStdOut; // Grab
 440 ~listing.reverse.as(Array).stutter.join.postln; // Mangle
 441 ::
 442
 443 method::systemCmd
 444 Executes a unix command synchronously using the standard shell (sh).
 445
 446 returns:: Error code of the unix command
 447
 448 method::runInTerminal
 449 Execute the String in a new terminal window (asynchronously).
 450 argument::shell
 451 The shell used to execute the string.
 452 discussion::
 453 note:: On OSX, the string is incorporated into a temporary script file and executed using the shell. ::
 454 Example:
 455 code::
 456 "echo ---------Hello delightful SuperCollider user----------".runInTerminal;
 457 ::
 458
 459 method::setenv
 460 Set the environment variable indicated in the string to equal the String strong::value::. This value will persist until it is changed or SC is quit. Note that if strong::value:: is a path you may need to call link::#-standardizePath:: on it.
 461 code::
 462 // all defs in this directory will be loaded when a local server boots
 463 "SC_SYNTHDEF_PATH".setenv("~/scwork/".standardizePath);
 464 "echo $SC_SYNTHDEF_PATH".unixCmd;
 465 ::
 466
 467 method::getenv
 468 Returns the value contained in the environment variable indicated by the String.
 469 code::
 470 "USER".getenv;
 471 ::
 472
 473 method::pathMatch
 474 Returns an link::Classes/Array:: containing all paths matching this String. Wildcards apply, non-recursive.
 475 code::
 476 Post << "Help/*".pathMatch;
 477 ::
 478
 479 method::loadPaths
 480 Perform link::#-pathMatch:: on this String, then load and execute all paths in the resultant link::Classes/Array::.
 481 code::
 482 //first prepare a file with some code...
 483 (
 484 var f = File("/tmp/loadPaths_example.scd", "w");
 485 if(f.isOpen, {
 486         f.putString("\"This text is the result of a postln command which was loaded and executed by loadPaths\".postln");
 487 }, {
 488         "test file could not be created - please edit the file's path above".warn;
 489 });
 490 f.close;
 491 )
 492
 493 //then load the file...
 494 "/tmp/loadPaths_example.scd".loadPaths; //This file posts some text
 495 ::
 496
 497 method::load
 498 Load and execute the file at the path represented by the receiver.
 499 ::
 500
 501 method::loadRelative
 502 Load and execute the file at the path represented by the receiver, interpreting the path as relative to the current document or text file. Requires that the file has been saved.
 503
 504 method::resolveRelative
 505 Convert the receiver from a relative path to an absolute path, relative to the current document or text file. Requires that the current text file has been saved. Absolute paths are left untransformed.
 506
 507 method::standardizePath
 508 Expand ~ to your home directory, and resolve aliases on OSX. See link::Classes/PathName:: for more complex needs. See link::Classes/File#*realpath:: if you want to resolve symlinks.
 509 code::
 510 "~/".standardizePath; //This will print your home directory
 511 ::
 512
 513
 514 method::openOS
 515 Open file, directory or URL via the operating system. On OSX this is implemented via teletype::open::, on Linux via
 516 teletype::xdg-open:: and on Windows via teletype::start::.
 517 code::
 518 Platform.userConfigDir.openOS;
 519 "http://supercollider.sf.net".openOS;
 520 ::
 521
 522 subsection::Pathname Support
 523
 524 Also see link::#-+/+:: for path concatenation.
 525
 526 method::absolutePath
 527 method::asAbsolutePath
 528 Return this path as an absolute path by prefixing it with link::Classes/File#*getcwd:: if necessary.
 529
 530 method::asRelativePath
 531 Return this path as relative to the specified path.
 532 argument::relativeTo
 533 The path to make this path relative to.
 534
 535 method::withTrailingSlash
 536 Return this string with a trailing slash if that was not already the case.
 537
 538 method::withoutTrailingSlash
 539 Return this string without a trailing slash if that was not already the case.
 540
 541 method::basename
 542 Return the filename from a Unix path.
 543 code::
 544 "Imaginary/Directory/fish.rtf".basename;
 545 ::
 546
 547 method::dirname
 548 Return the directory name from a Unix path.
 549 code::
 550 "Imaginary/Directory/fish.rtf".dirname;
 551 ::
 552
 553 method::splitext
 554 Split off the extension from a filename or path and return both in an link::Classes/Array:: as [path or filename, extension].
 555 code::
 556 "fish.rtf".splitext;
 557 "Imaginary/Directory/fish.rtf".splitext;
 558 ::
 559
 560 subsection::Document Support
 561
 562 method::newTextWindow
 563 Create a new link::Classes/Document:: with this.
 564 code::
 565 "Here is a new Document".newTextWindow;
 566 ::
 567
 568 method::openDocument
 569 Create a new link::Classes/Document:: from the path corresponding to this. Returns the Document.
 570 code::
 571 (
 572 d = "Help/Help.html".openDocument;
 573 d.class;
 574 )
 575 ::
 576
 577 method::openTextFile
 578 Create a new link::Classes/Document:: from the path corresponding to this. The selection arguments will preselect the indicated range in the new window. Returns this.
 579 code::
 580 (
 581 d = "Help/Help.html".openTextFile(20, 210);
 582 d.class;
 583 )
 584 ::
 585
 586 method::findHelpFile
 587 Returns the path for the helpfile named this, if it exists, else returns nil.
 588 code::
 589 "Document".findHelpFile;
 590 "foobar".findHelpFile;
 591 ::
 592
 593 method::openHelpFile
 594 Performs link::#-findHelpFile:: on this, and opens the file it if it exists, otherwise opens the main helpfile.
 595 code::
 596 "Document".openHelpFile;
 597 "foobar".openHelpFile;
 598 ::
 599
 600 subsection::Misc methods
 601
 602 method::speak
 603 Sends string to the speech synthesisier of the OS. (OS X only.) see: link::Classes/Speech::
 604 code::
 605 "hi i'm talking with the default voice now, i guess".speak;
 606 ::
 607
 608 method::inspectorClass
 609 Returns class link::Classes/StringInspector::.
 610
 611
 612 subsection::Drawing Support
 613
 614 The following methods must be called within an Window-drawHook or a SCUserView-drawFunc function, and will only be visible once the window or the view is refreshed. Each call to Window-refresh SCUserView-refresh will 'overwrite' all previous drawing by executing the currently defined function.
 615
 616 See also: link::Classes/Window::, link::Classes/UserView::, link::Classes/Color::, and link::Classes/Pen::.
 617
 618 note::
 619 for cross-platform GUIs, use code::Pen.stringAtPoint, Pen.stringInRect, Pen.stringCenteredIn, Pen.stringLeftJustIn, Pen.stringRightJustIn:: instead.
 620 ::
 621
 622 method::draw
 623 Draws the String at the current 0@0 link::Classes/Point::. If not transformations of the graphics state have taken place this will be the upper left corner of the window. See also link::Classes/Pen::.
 624 code::
 625 (
 626 w = Window.new.front;
 627 w.view.background_(Color.white);
 628 w.drawHook = {
 629         "abababababa\n\n\n".scramble.draw
 630 };
 631 w.refresh
 632 )
 633 ::
 634
 635 method::drawAtPoint
 636 Draws the String at the given link::Classes/Point:: using the link::Classes/Font:: and link::Classes/Color:: specified.
 637 code::
 638 (
 639 w = Window.new.front;
 640 w.view.background_(Color.white);
 641 w.drawHook = {
 642         "abababababa\n\n\n".scramble.drawAtPoint(
 643                 100@100,
 644                 Font("Courier", 30),
 645                 Color.blue(0.3, 0.5))
 646 };
 647 w.refresh;
 648 )
 649 ::
 650
 651 method::drawInRect
 652 Draws the String into the given link::Classes/Rect:: using the link::Classes/Font:: and link::Classes/Color:: specified.
 653 code::
 654 (
 655 w = Window.new.front;
 656 r = Rect(100, 100, 100, 100);
 657 w.view.background_(Color.white);
 658 w.drawHook = {
 659         "abababababa\n\n\n".scramble.drawInRect(r, Font("Courier", 12), Color.blue(0.3, 0.5));
 660         Pen.strokeRect(r);
 661 };
 662 w.refresh;
 663 )
 664 ::
 665
 666 method::drawCenteredIn
 667 Draws the String into the given Rect using the Font and Color specified.
 668 code::
 669 (
 670 w = Window.new.front;
 671 w.view.background_(Color.white);
 672 r = Rect(100, 100, 100, 100);
 673 w.drawHook = {
 674         "abababababa\n\n\n".scramble.drawCenteredIn(
 675                 r,
 676                 Font("Courier", 12),
 677                 Color.blue(0.3, 0.5)
 678         );
 679         Pen.strokeRect(r);
 680 };
 681 w.refresh;
 682 )
 683 ::
 684
 685 method::drawLeftJustIn
 686 Draws the String into the given Rect using the Font and Color specified.
 687 code::
 688 (
 689 w = Window.new.front;
 690 w.view.background_(Color.white);
 691 r = Rect(100, 100, 100, 100);
 692 w.drawHook = {
 693         "abababababa\n\n\n".scramble.drawLeftJustIn(
 694                 r,
 695                 Font("Courier", 12),
 696                 Color.blue(0.3, 0.5)
 697         );
 698         Pen.strokeRect(r);
 699 };
 700 w.refresh;
 701 )
 702 ::
 703
 704 method::drawRightJustIn
 705 Draws the String into the given link::Classes/Rect:: using the link::Classes/Font:: and link::Classes/Color:: specified.
 706 code::
 707 (
 708 w = Window.new.front;
 709 w.view.background_(Color.white);
 710 r = Rect(100, 100, 100, 100);
 711 w.drawHook = {
 712         "abababababa\n\n\n".scramble.drawRightJustIn(
 713                 r,
 714                 Font("Courier", 12),
 715                 Color.blue(0.3, 0.5)
 716         );
 717         Pen.strokeRect(r);
 718 };
 719 w.refresh;
 720 )
 721 ::
 722
 723 method::bounds
 724 Tries to return a link::Classes/Rect:: with the size needed to fit this string if drawed with given font.
 725 argument:: font
 726 A link::Classes/Font::
 727