C++/Tk library

In addition to the fact that every option name and some of the command names can be used as string constants, there is also a set of constants defined in the cpptkconstants.x file.

1. To help creating indexes (entry, canvas, text, etc.), the following helper functions are provided:
   • at(x, y) creates string "@x,y"
   • at(x) creates string "@x"
   • txt(ln, ch) creates string "ln.ch"
   
   
2. The std::string rgb(r, g, b); function formats the "#rrggbb" string, useful for color definitions.
   
   
3. To specify substitutions in the bind command, the following specifiers can be used (equivalent to % substitutions in Tcl/Tk):
   
   event_A
event_b
event_D
event_f
event_h
event_k
event_K
event_m
event_N
event_s
event_T
event_w
event_W
event_x
event_X
event_y
event_Y
   
   Note: the number and types of parameters in the function or function object used for callback must be compatible with the specifiers.
   
   
4. To specify sibstitutions in the validatecommand option of the entry widget, the following specifiers can be used (equivalent to % substitutions in Tcl/Tk):
   
   valid_d
valid_i
valid_P
valid_s
valid_S
valid_v
valid_V
valid_W
   
   Note 1: the callback function or function object has to return something that is convertible to bool, int, double or std::string.
   Note 2: the number and types of parameters in the function or function object used for callback must be compatible with the specifiers.
   
   
5. Defining callbacks.
   Every functor with compatible set of parameters can be used in options and functions like command, after, etc. In addition, the following are provided:
   • template <class Functor> std::string callback(Functor f); - this function will register a callback and return a name for respective Tcl procedure. This name can be used in those places where the callback is expected, but the registration takes place only once.
   • void deleteCallback(std::string const &name); - this function unregisters a callback with the given name.
   • class CallbackHandle; - this class ca be used as a RAII wrapper for registering and unregistering callbacks. The get() method is used to retrieve the callback name.
     
     
6. Conversions.
   A C++/Tk expression, after execution, can leave some result in the interpreter. This result can be retrieved by converting the whole expression into one of the following types:
   • std::string()
   • int
   • double
   • Tk::Point (a class with two int members: x and y)
   • Tk::Box (a class with four int members: x1, y1, x2 and y2)
   • std::pair<T1, T2>
   • std::vector<T>
   
   
7. Additional helper functions:
   • template <typename T> std::string linkVar(T &t); - used to create an explicit link between C++ variable and Tcl variable. Returns the name of Tcl variable.
   • template <typename T> void unLinkVar(T &t); - used to remove the linking between C++ variable and Tcl variable.
   • class LinkHandle; - can be used as a RAII wrapper for linking variables. The get() method is used to retrieve the name of respective Tcl variable.
   • std::string eval(std::string const &str); - this function forces evaluation of the given script. Can be used when everything else fails. :-)
   • void init(char *argv0); - should be called at the beginning of the C++/Tk program with the value of argv[0].
   • void runEventLoop(); - runs the Tk event toop. Normally never returns.
   • void setDumpStream(std::ostream &os); - set the stream for dumping Tcl/Tk commands. Can be useful for testing and debugging.
     

The whole C++/Tk library consists of the following files: cpptk.h, cpptk.cc, cpptkoptions.x, cpptkconstants.x, base/cpptkbase.h and base/cpptkbase.cc.

The cpptk.cc and base/cpptkbase.cc files can be compiled to the object files and reused in many projects, just like in the example programs. They may also be compiled to the form of an archive or a shared library.

It is important to note that the *.x files are not compilable and should not be included as project files in the IDE. However, they should be placed in a directory where they can be visible by the preprocessor while compiling the project (they are #included by cpptk.h and cpptk.cc).

Dependencies