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