itcl(3itcl)

💖 itcl — the manual page, but make it cute 💖

okay bestie, welcome to itcl(3itcl), the page that explains [incr Tcl] — object-oriented extensions to Tcl. yes, this is the manual for the whole vibe. strap in. 🎀

---

✨ NAME ✨

itcl — object-oriented extensions to Tcl. that's it, that's the name, iconic. 💅

---

🌸 DESCRIPTION 🌸

[incr Tcl] hands Tcl some object-oriented extensions, the same way C++ hands C some object-oriented extensions. but here's the thing — and this is lowkey important — the whole point of this work is not to build some whiz-bang object-oriented programming environment. nope. the goal is to support more structured programming practices in Tcl without changing the flavor of the language. 🍓

more than anything else, [incr Tcl] gives you a way to encapsulate related procedures together with their shared data in a namespace that is hidden from the outside world. it encourages better programming by promoting the object-oriented "library" mindset, and it also lets you reuse code through inheritance. slay. ✨

---

👑 CLASSES 👑

the fundamental construct in [incr Tcl] is the class definition. each class acts as a template for actual objects that can be created. every object gets its own unique bundle of data, and that bundle holds instances of the "variables" defined in the class. special procedures called "methods" are what you use to manipulate individual objects. 🦋

methods are literally just like the operations you use to poke at Tk widgets. the button widget, for example, has methods such as flash and invoke that make a particular button blink and invoke its command. same energy. 💫

inside the body of a method, the "variables" defined in the class are automatically available — you do not need to declare them with anything like the global command. from within another class method, you can invoke a method like any other command, simply by using its name. but from any other context, the method name has to be prefaced by an object name, which gives you a context for the data that the method can access. 🔑

every class has its own namespace containing the things that are common to all objects belonging to that class. for example, "common" data members are shared by all objects in the class — they're global variables that live in the class namespace, but because they're included in the class definition you don't have to declare them with the global command. they're automatically available to any code executing in the class context. a class can also create ordinary global variables, but those must be declared using the global command each and every time they're used. no shortcuts there. 🙈

classes can also have ordinary procedures declared as "procs". within another class method or proc, you can invoke a proc like any other command — simply by using its name. from any other context, the procedure name should be qualified with the class namespace, like className::proc. class procs execute in the class context, so they get automatic access to all "common" data members. but — and this is the catch — they cannot access object-specific "variables", because they're invoked without reference to any specific object. they're usually used to perform generic operations that affect all objects belonging to the class. 💜

🔐 public, protected, private 🔐

each element in a class can be declared public, protected or private. here's the breakdown:

• public — accessible by the class, by derived classes (other classes that inherit this class), and by external clients that use the class.
• protected — accessible by the class, and by derived classes.
• private — only accessible in the class where they're defined.

the public elements within a class define its interface to the external world. public methods define the operations you can use to manipulate an object, and public variables are recognized as configuration options by the configure and cget methods that are built into each class. the public interface says what an object will do, not how it will do it. 💅

protected and private members, along with the bodies of class methods and procs, provide the implementation details. insulating the application developer from those details leaves the class designer free to change them at any time, without warning, and without affecting programs that rely on the class. and it is precisely this encapsulation that makes object-oriented programs easier to understand and maintain. periodt. 🎀

🫶 the whole Tk-widget thing 🫶

the fact that [incr Tcl] objects look like Tk widgets is no accident. [incr Tcl] was designed this way so it blends naturally into a Tcl/Tk application. but [incr Tcl] extends the Tk paradigm from being merely object-based to being fully object-oriented. 🌈

an object-oriented system supports inheritance, which lets classes share common behaviors by inheriting them from an ancestor or base class. having a base class as a common abstraction lets a programmer treat related classes in a similar manner. for example: a toaster and a blender perform different (specialized) functions, but both share the abstraction of being appliances. 🍞🥤 by abstracting common behaviors into a base class, code can be shared rather than copied. the resulting application is easier to understand and maintain, and derived classes (e.g., specialized appliances) can be added or removed more easily. honestly? genius. ✨

this description was merely a brief overview of object-oriented programming and [incr Tcl]. a more tutorial introduction is presented in the paper included with this distribution. see the class command for more details on creating and using classes. 📚

---

🧚 NAMESPACES 🧚

[incr Tcl] now includes a complete namespace facility. a namespace is a collection of commands and global variables that is kept apart from the usual global scope. this lets Tcl code libraries be packaged in a well-defined manner and prevents unwanted interactions with other libraries. 🌸

a namespace can also have child namespaces within it, so one library can contain its own private copy of many other libraries. a namespace can also be used to wrap up a group of related classes. the global scope (named ::) is the root namespace for an interpreter; all other namespaces are contained within it. 🌳

see the namespace command for details on creating and using namespaces. 💫

---

🔥 MEGA-WIDGETS 🔥

mega-widgets are high-level widgets constructed using Tk widgets as component parts, usually without any C code. a fileselectionbox, for example, may have a few listboxes, some entry widgets and some control buttons. these individual widgets are put together in a way that makes them act like one big widget. 👑

[incr Tk] is a framework for building mega-widgets. it uses [incr Tcl] to support the object paradigm, and adds base classes which provide default widget behaviors. see the itk man page for more details. 🛠️

[incr Widgets] is a library of mega-widgets built using [incr Tk]. it contains more than 30 different widget classes that can be used right out of the box to build Tcl/Tk applications. each widget class has its own man page describing the features available. that's a whole lotta widgets, bestie. 🎁

---

⭐ KEYWORDS ⭐

class, object, object-oriented, namespace, mega-widget

---

and that's the whole page, you're welcome. this was itcl, version 3.0, from the [incr Tcl] manual, dated itcl(3itcl) — go build something iconic with it. mwah. 💖✨🦋