diff options
Diffstat (limited to 'zinclib.d/src')
| -rw-r--r-- | zinclib.d/src/Zinc.cpp | 4540 | ||||
| -rw-r--r-- | zinclib.d/src/Zinc.hpp | 1365 | ||||
| -rw-r--r-- | zinclib.d/src/ZincExtern.hpp | 74 | ||||
| -rw-r--r-- | zinclib.d/src/ZincInternal.hpp | 182 | ||||
| -rw-r--r-- | zinclib.d/src/ZincObjects.cpp | 201 | ||||
| -rw-r--r-- | zinclib.d/src/ZincObjects.hpp | 198 | ||||
| -rw-r--r-- | zinclib.d/src/ZincPath.cpp | 415 | ||||
| -rw-r--r-- | zinclib.d/src/ZincPath.hpp | 162 | ||||
| -rw-r--r-- | zinclib.d/src/ZincTypes.hpp | 188 |
9 files changed, 7325 insertions, 0 deletions
diff --git a/zinclib.d/src/Zinc.cpp b/zinclib.d/src/Zinc.cpp new file mode 100644 index 0000000..4c60acf --- /dev/null +++ b/zinclib.d/src/Zinc.cpp @@ -0,0 +1,4540 @@ +/** Zinc.cpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here is the definition of the Zinc object + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * David Thevenin <thevenin@intuilab.com> + * + */ +#include "Zinc.hpp" +#include "ZincInternal.hpp" +#include <iostream> +#include <sstream> +#include <tk.h> + +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL (1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ + +//predeclare private function +#ifdef _WIN32 +int __cdecl tclCallback (ClientData client_data, Tcl_Interp *interp, + int argc, Tcl_Obj *CONST args[]); +#else +int tclCallback (ClientData client_data, Tcl_Interp *interp, + int argc, Tcl_Obj *CONST args[]) __attribute__((cdecl)); +#endif + +/******************************************************* + ZINC OBJECT +*******************************************************/ + + +int Zinc::znCount = 0; ///< count to create unique ids +Tcl_Interp *Zinc::interp; ///< the tcl interpreter +Tcl_CmdInfo Zinc::topCmdInfo; ///< the command associated with toplevel +Tcl_CmdInfo Zinc::zncCmdInfo; ///< the command associated with zinc +Tcl_CmdInfo Zinc::imgCmdInfo; ///< the command associated with image +Tcl_CmdInfo Zinc::fntCmdInfo; ///< the command associated with font +Tcl_CmdInfo Zinc::focCmdInfo; ///< the command associated with focus +Tcl_CmdInfo Zinc::bndCmdInfo; ///< the command associated with bind +Tcl_Obj* Zinc::pool[ZINC_POOL_COUNT];///< a pool of tclobj ready to be used +Tcl_Obj* Zinc::p1[ZINC_PARAM_COUNT]; ///< a table of pointeurs use for parameters +Tcl_Obj* Zinc::p2[ZINC_PARAM_COUNT]; ///< a table of pointeurs use for parameters + +static Tcl_Obj *DEFAULT_GROUP_OBJ = Tcl_NewIntObj (DEFAULT_GROUP); + +//option constants +//Tcl_Obj* Z_render = Tcl_NewStringObj ("-render", -1); +Z_DEFINE_ZOPT (render); ///< the "-render" option +Z_DEFINE_ZOPT (firstend); ///< the "-firstend" option +Z_DEFINE_ZOPT (lastend); ///< the "-lastend" option +Z_DEFINE_ZOPT (position); ///< the "-position" option +Z_DEFINE_ZOPT (tags); ///< the "-tags" option +Z_DEFINE_ZOPT (backcolor); ///< the "-backcolor" option +Z_DEFINE_ZOPT (forecolor); ///< the "-forecolor" option +Z_DEFINE_ZOPT (height); ///< the "-height" option +Z_DEFINE_ZOPT (borderwidth); ///< the "-borderwidth" option + + +//autogenerated constants +Z_DEFINE_ZOPT (closed); ///< the "-closed" option +Z_DEFINE_ZOPT (composealpha); ///< the "-composealpha" option +Z_DEFINE_ZOPT (composerotation); ///< the "-composerotation" option +Z_DEFINE_ZOPT (composescale); ///< the "-composescale" option +Z_DEFINE_ZOPT (extent); ///< the "-extent" option +Z_DEFINE_ZOPT (fillcolor); ///< the "-fillcolor" option +Z_DEFINE_ZOPT (filled); ///< the "-filled" option +Z_DEFINE_ZOPT (fillpattern); ///< the "-fillpattern" option +Z_DEFINE_ZOPT (linecolor); ///< the "-linecolor" option +Z_DEFINE_ZOPT (linepattern); ///< the "-linepattern" option +Z_DEFINE_ZOPT (linestyle); ///< the "-linestyle" option +Z_DEFINE_ZOPT (linewidth); ///< the "-linewidth" option +Z_DEFINE_ZOPT (pieslice); ///< the "-pieslice" option +Z_DEFINE_ZOPT (priority); ///< the "-priority" option +Z_DEFINE_ZOPT (sensitive); ///< the "-sensitive" option +Z_DEFINE_ZOPT (startangle); ///< the "-startangle" option +Z_DEFINE_ZOPT (tile); ///< the "-tile" option +Z_DEFINE_ZOPT (visible); ///< the "-visible" option +Z_DEFINE_ZOPT (capstyle); ///< the "-capstyle" option +Z_DEFINE_ZOPT (fillrule); ///< the "-fillrule" option +Z_DEFINE_ZOPT (joinstyle); ///< the "-joinstyle" option +Z_DEFINE_ZOPT (marker); ///< the "-marker" option +Z_DEFINE_ZOPT (markercolor); ///< the "-markercolor" option +Z_DEFINE_ZOPT (relief); ///< the "-relief" option +Z_DEFINE_ZOPT (smoothrelief); ///< the "-smoothrelief" option +Z_DEFINE_ZOPT (alpha); ///< the "-alpha" option +Z_DEFINE_ZOPT (atomic); ///< the "-atomic" option +Z_DEFINE_ZOPT (clip); ///< the "-clip" option +Z_DEFINE_ZOPT (anchor); ///< the "-anchor" option +Z_DEFINE_ZOPT (color); ///< the "-color" option +Z_DEFINE_ZOPT (connecteditem); ///< the "-connecteditem" option +Z_DEFINE_ZOPT (connectionanchor); ///< the "-connectionanchor" option +Z_DEFINE_ZOPT (image); ///< the "-image" option +Z_DEFINE_ZOPT (mask); ///< the "-mask" option +Z_DEFINE_ZOPT (alignment); ///< the "-alignment" option +Z_DEFINE_ZOPT (font); ///< the "-font" option +Z_DEFINE_ZOPT (overstriked); ///< the "-overstriked" option +Z_DEFINE_ZOPT (spacing); ///< the "-spacing" option +Z_DEFINE_ZOPT (text); ///< the "-text" option +Z_DEFINE_ZOPT (underlined); ///< the "-underlined" option +Z_DEFINE_ZOPT (width); ///< the "-width" option + +//other constants +Z_DEFINE_ZFCT (device); ///< the "device" keyword + +///< function constants +Z_DEFINE_ZFCT (add); ///< the "add" function +Z_DEFINE_ZFCT (addtag); ///< the "addtag" function +Z_DEFINE_ZFCT (bind); ///< the "bind" function +Z_DEFINE_ZFCT (bbox); ///< the "bbox" function +Z_DEFINE_ZFCT (cget); ///< the "cget" function +Z_DEFINE_ZFCT (chggroup); ///< the "chggroup" function +Z_DEFINE_ZFCT (clone); ///< the "clone" function +Z_DEFINE_ZFCT (configure); ///< the "configure" function +Z_DEFINE_ZFCT (contour); ///< the "contour" function +Z_DEFINE_ZFCT (coords); ///< the "coords" function +Z_DEFINE_ZFCT (dtag); ///< the "dtag" function +Z_DEFINE_ZFCT (focus); ///< the "focus" function +Z_DEFINE_ZFCT (gettags); ///< the "gettags" function +Z_DEFINE_ZFCT (gname); ///< the "gname" function +Z_DEFINE_ZFCT (group); ///< the "group" function +Z_DEFINE_ZFCT (itemconfigure); ///< the "itemconfigure" function +Z_DEFINE_ZFCT (itemcget); ///< the "itemcget" function +Z_DEFINE_ZFCT (lower); ///< the "lower" function +Z_DEFINE_ZFCT (raise); ///< the "raise" function +Z_DEFINE_ZFCT (remove); ///< the "remove" function +Z_DEFINE_ZFCT (rotate); ///< the "rotate" function +Z_DEFINE_ZFCT (scale); ///< the "scale" function +Z_DEFINE_ZFCT (skew); ///< the "skew" function +Z_DEFINE_ZFCT (tget); ///< the "tget" function +Z_DEFINE_ZFCT (translate); ///< the "translate" function +Z_DEFINE_ZFCT (transform); ///< the "transform" function +Z_DEFINE_ZFCT (treset); ///< the "treset" function +Z_DEFINE_ZFCT (tset); ///< the "tset" function +Z_DEFINE_ZFCT (type); ///< the "type" function + +//Item constants +Z_DEFINE_ZITM (add); ///< the "add" constant +Z_DEFINE_ZITM (arc); ///< the "arc" constant +Z_DEFINE_ZITM (curve); ///< the "curve" constant +Z_DEFINE_ZITM (icon); ///< the "icon" constant +Z_DEFINE_ZITM (group); ///< the "group" constant +Z_DEFINE_ZITM (rectangle); ///< the "rectangle" constant +Z_DEFINE_ZITM (text); ///< the "text" constant +Z_DEFINE_ZITM (withtag); ///< the "withtag" constant + +/********************************************* + Prepare enum Tcl_Obj +*********************************************/ + +//lineStyles strings +const char* lineStylesStrings [] = +{ "simple", "dashed", "mixed", "dotted" }; +//lineStyles Tcl_Obj +Tcl_Obj* lineStyles [] = +{ + Tcl_NewStringObj ("simple", -1), + Tcl_NewStringObj ("dashed", -1), + Tcl_NewStringObj ("mixed", -1), + Tcl_NewStringObj ("dotted", -1), +}; + +//capStyles strings +const char* capStylesStrings [] = +{ "butt", "projecting", "round" }; +//capStyles Tcl_Obj +Tcl_Obj* capStyles [] = +{ + Tcl_NewStringObj ("butt", -1), + Tcl_NewStringObj ("projecting", -1), + Tcl_NewStringObj ("round", -1), +}; + +// fillRules strings +const char* fillRulesStrings [] = +{ "odd", "nonzero", "positive", "negative", "abs_geq_2" }; +//fillRules Tcl_Obj +Tcl_Obj* fillRules [] = +{ + Tcl_NewStringObj ("odd", -1), + Tcl_NewStringObj ("nonzero", -1), + Tcl_NewStringObj ("positive", -1), + Tcl_NewStringObj ("negative", -1), + Tcl_NewStringObj ("abs_geq_2", -1), +}; + +// joinStyle strings +const char* joinStylesStrings [] = +{ "bevel", "miter", "round" }; +// joinStyles Tcl_Obj +Tcl_Obj* joinStyles [] = +{ + Tcl_NewStringObj ("bevel", -1), + Tcl_NewStringObj ("miter", -1), + Tcl_NewStringObj ("round", -1), +}; + +// reliefs strings +const char* reliefsStrings [] = +{ "flat", "raised", "sunken", "ridge", "groove", "roundraised", + "roundsunken", "roundridge", "roundgroove", "raisedrule", "sunkenrule" }; +// reliefs Tcl_Obj +Tcl_Obj* reliefs [] = +{ + Tcl_NewStringObj ("flat", -1), + Tcl_NewStringObj ("raised", -1), + Tcl_NewStringObj ("sunken", -1), + Tcl_NewStringObj ("ridge", -1), + Tcl_NewStringObj ("groove", -1), + Tcl_NewStringObj ("roundraised", -1), + Tcl_NewStringObj ("roundsunken", -1), + Tcl_NewStringObj ("roundridge", -1), + Tcl_NewStringObj ("roundgroove", -1), + Tcl_NewStringObj ("raisedrule", -1), + Tcl_NewStringObj ("sunkenrule", -1), +}; + +// alignments strings +const char* alignmentsStrings [] = +{ "left", "right", "center" }; +// alignments Tcl_obj +Tcl_Obj* alignments [] = +{ + Tcl_NewStringObj ("left", -1), + Tcl_NewStringObj ("right", -1), + Tcl_NewStringObj ("center", -1), +}; + +// anchors strings +const char* anchorsStrings [] = +{ "nw", "n", "ne", "e", "se", "s", "sw", "w", "center" }; +// anchors Tcl_Obj +Tcl_Obj* anchors [] = +{ + Tcl_NewStringObj ("nw", -1), + Tcl_NewStringObj ("n", -1), + Tcl_NewStringObj ("ne", -1), + Tcl_NewStringObj ("e", -1), + Tcl_NewStringObj ("se", -1), + Tcl_NewStringObj ("s", -1), + Tcl_NewStringObj ("sw", -1), + Tcl_NewStringObj ("w", -1), + Tcl_NewStringObj ("center", -1), +}; + +// itemType strings +const char* itemTypeStrings [] = +{ + "group", + "arc", + "text", + "rectangle", + "curve", + "icon", + NULL +}; +//no need for Tcl_Objs because they are only used as return values + + +/********************************** + Zinc Object +**********************************/ + +/** + * The public constructor + * + * @param renderingMode ZINC_BACKEND_X11 or ZINC_BACKEND_OPENGL + */ +Zinc::Zinc (int renderingMode) +{ + String theId; + + //preparating id (.zn and a unique number) + znCount++; + theId = ".zn"; + theId += itos(znCount); + window = "."; + + //create a new window for each other widget + if (znCount != 1) + { + window = ".zwin"; + window += itos (znCount); + + //create a new toplevel window + const char* para[2]; + para[0] = "toplevel"; + para[1] = window.c_str(); + //call the toplevel Tk function with 2 arguments + z_tcl_call ((*topCmdInfo.proc)(topCmdInfo.clientData, interp, 2, para), + "toplevel Failed : "); + + //adapt the zinc id to the window path + theId = window + theId; + } + + // String noResizeCommand = String ("wm resizable ") + window + " 0 0"; + //Tcl_Eval (interp, noResizeCommand.c_str ()); + + //use a tcl_obj for the id + id = Tcl_NewStringObj (theId.c_str (), theId.length ()); + Tcl_IncrRefCount (id); + + //get top windows for zinc widget + Tk_Window top_w = Tk_MainWindow (interp); + + //creation of the zinc item + // call "Zinc id -render mode + Tcl_ResetResult (interp); + p1[0] = NULL; + p1[1] = id; + p1[2] = ZOPT_render; + p1[3] = Z_INT_POOL (0, renderingMode); + // call the function with 4 arguments and check non error + z_tcl_call ((*zncCmdInfo.objProc) (ClientData (top_w), interp, 4, p1), + "ZincObjCmd failed :"); + + // get back ZnWInfo *wi and WidgetObjCmd + Tcl_CmdInfo cmdInfo; + int result = Tcl_GetCommandInfo (interp, theId.c_str (), &cmdInfo); + if (!result) + { + throw ZincException (String ("zinclib: Tcl command not found") + + Tcl_GetStringResult (interp), __FILE__, __LINE__); + } + + //get informations necessary to call WidgetObjCmd + wi = cmdInfo.objClientData; + objCmd = (WidgetObjCmd)cmdInfo.objProc; + + //call the Tk function pack + String packCmd = String ("pack ") + theId + " -expand 1 -fill both"; + Tcl_Eval (interp, packCmd.c_str ()); + + // Prepare for binding with callback (create a Tcl function) + tclCb = String (Z_TCLCB) + itos(znCount); + Tcl_CreateObjCommand(interp, tclCb.c_str (), tclCallback, + (ClientData) this, (Tcl_CmdDeleteProc *) NULL); + + //give focus to the window + const char* para[2]; + para[0] = "focus"; + para[1] = theId.c_str(); + // call the function with 4 arguments + z_tcl_call ((*focCmdInfo.proc)(focCmdInfo.clientData, interp, 2, para), + "focus Failed : "); +} + +/** + * The public destructor + */ +Zinc::~Zinc () +{ + //delete the Tcl function + Tcl_DeleteCommand (interp, tclCb.c_str ()); + // delete the tcl_obj + Tcl_DecrRefCount (id); +} + +/** + * Change window title + * + * @param title the title string + */ +void Zinc::setTitle (String title) +{ + //use tcl interpreter directly since this won't be called often + String command = String ("wm title ") + window + " \"" + title + "\""; + Tcl_Eval (interp, command.c_str ()); +} + +/***************************************** + WIDGET PROPERTIES +*****************************************/ +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ + +/** + * Call zinc->configure ( -backcolor ) + * + * @param value the backcolor to set + */ +void Zinc::setBackcolor (String value) +{ + //call .zinc configure -backcolor value + p1[0] = id; + p1[1] = ZFCT_configure; + p1[2] = ZOPT_backcolor; + p1[3] = Z_STR_POOL (0, value.c_str(), value.length()); + // call the function with 4 arguments + z_command (4, "setBackcolor Failed : "); +} + +/** + * Call zinc->cget ( -backcolor ) + * + * @return backcolor value + */ +String Zinc::getBackcolor () +{ + Tcl_Obj* tmp; + //discard old results + Tcl_ResetResult (interp); + //call .zinc cget -backcolor + p1[0] = id; + p1[1] = ZFCT_cget; + p1[2] = ZOPT_backcolor; + // call the function with 3 arguments + z_command (3, "getBackcolor Failed : "); + + //retreive the result as a string + tmp = Tcl_GetObjResult (interp); + return String (Tcl_GetStringFromObj (tmp, NULL)); +} + +/** + * Call zinc->configure ( -forecolor ) + * + * @param value the forecolor to set + */ +void Zinc::setForecolor (String value) +{ + //call .zinc configure -forecolor value + p1[0] = id; + p1[1] = ZFCT_configure; + p1[2] = ZOPT_forecolor; + p1[3] = Z_STR_POOL (0, value.c_str(), value.length()); + // call the function with 4 arguments + z_command (4, "setForecolor Failed : "); +} + +/** + * Call zinc->cget ( -forecolor ) + * + * @return forecolor value + */ +String Zinc::getForecolor () +{ + Tcl_Obj* tmp; + //discard old results + Tcl_ResetResult (interp); + //call .zinc cget -forecolor + p1[0] = id; + p1[1] = ZFCT_cget; + p1[2] = ZOPT_forecolor; + // call the function with 3 arguments + z_command (3, "getForecolor Failed : "); + + //retreive the result as a string + tmp = Tcl_GetObjResult (interp); + return String (Tcl_GetStringFromObj (tmp, NULL)); +} + +/** + * Call zinc->configure ( -width ) + * + * @param value the width to set + */ +void Zinc::setWidth (int value) +{ + //call .zinc configure -width value + p1[0] = id; + p1[1] = ZFCT_configure; + p1[2] = ZOPT_width; + p1[3] = Z_INT_POOL (0, value); + // call the function with 4 arguments + z_command (4, "setWidth Failed : "); + + char *strid = Tcl_GetString(id); + //call the Tk function pack + String packCmd = String ("pack ") + strid + " -expand 1 -fill both"; + Tcl_Eval (interp, packCmd.c_str ()); +} + +/** + * Call zinc->cget ( -width ) + * + * @return width value + */ +int Zinc::getWidth () +{ + Tcl_Obj* tmp; + //discard old results + Tcl_ResetResult (interp); + //call .zinc cget -width + p1[0] = id; + p1[1] = ZFCT_cget; + p1[2] = ZOPT_width; + // call the function with 3 arguments + z_command (3, "getWidth Failed : "); + + //retreive the result as an integer + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "getWidth Failed : "); + return value; +} + +/** + * Call zinc->configure ( -height ) + * + * @param value the height to set + */ +void Zinc::setHeight (int value) +{ + //call .zinc configure -height value + p1[0] = id; + p1[1] = ZFCT_configure; + p1[2] = ZOPT_height; + p1[3] = Z_INT_POOL (0, value); + // call the function with 4 arguments + z_command (4, "setHeight Failed : "); + + char *strid = Tcl_GetString(id); + //call the Tk function pack + String packCmd = String ("pack ") + strid + " -expand 1 -fill both"; + Tcl_Eval (interp, packCmd.c_str ()); +} + +/** + * Call zinc->cget ( -height ) + * + * @return height value + */ +int Zinc::getHeight () +{ + Tcl_Obj* tmp; + //discard old results + Tcl_ResetResult (interp); + //call .zinc cget -height + p1[0] = id; + p1[1] = ZFCT_cget; + p1[2] = ZOPT_height; + // call the function with 3 arguments + z_command (3, "getHeight Failed : "); + + //retreive the result as an integer + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "getHeight Failed : "); + return value; +} + +/** + * Call zinc->configure ( -borderwidth ) + * + * @param value the borderwidth to set + */ +void Zinc::setBorderwidth (int value) +{ + //call .zinc configure -borderwidth value + p1[0] = id; + p1[1] = ZFCT_configure; + p1[2] = ZOPT_borderwidth; + p1[3] = Z_INT_POOL (0, value); + // call the function with 4 arguments + z_command (4, "setBorderwidth Failed : "); +} + +/** + * Call zinc->cget ( -borderwidth ) + * + * @return borderwidth value + */ +int Zinc::getBorderwidth () +{ + Tcl_Obj* tmp; + //discard old results + Tcl_ResetResult (interp); + //call .zinc cget -borderwidth + p1[0] = id; + p1[1] = ZFCT_cget; + p1[2] = ZOPT_borderwidth; + // call the function with 3 arguments + z_command (3, "getBorderwidth Failed : "); + + //retreive the result as an integer + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "getBorderwidth Failed : "); + return value; +} + +/** + * Call zinc->configure ( -font ) + * + * @param value the font to set + */ +void Zinc::setFont (ZincFont* value) +{ + //call .zinc configure -font value + p1[0] = id; + p1[1] = ZFCT_configure; + p1[2] = ZOPT_font; + p1[3] = Z_STR_POOL (0, value->name.c_str(), value->name.length()); + // call the function with 4 arguments + z_command (4, "setFont Failed : "); +} + +/** + * Call zinc->cget ( -font ) + * + * @return font value + */ +ZincFont* Zinc::getFont () +{ + //discard old results + Tcl_ResetResult (interp); + //call .zinc cget -font + p1[0] = id; + p1[1] = ZFCT_cget; + p1[2] = ZOPT_font; + // call the function with 3 arguments + z_command (3, "getFont Failed : "); + + //retreive the result as a string + return new ZincFont (Tcl_GetStringResult (interp)); +} + + +/***************************************** + WIDGET METHODS +*****************************************/ +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ + +/** + * Get the bounding box of an item + * + * @param item the item to get bbox + * @param bbox a table where we'll put the bounding box + * bbox[0] = x0, bbox[1] = y0, bbox[2] = xc, bbox[3] = yc + */ +void Zinc::bbox (ZincItem* item, double _bbox[4]) +{ + Tcl_Obj* tmp; + Tcl_Obj** list; + int count; + //discard old results + Tcl_ResetResult (interp); + // call .zinc bbox item + p1[0] = id; + p1[1] = ZFCT_bbox; + p1[2] = item->object; + + // call the function with 3 arguments + z_command (3, "bbox Failed : "); + + //retreive the result as a list + tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_ListObjGetElements (interp, tmp, &count, &list), + "bbox Failed : "); + //extract 4 double from the list + if (count != 4) + { + throw ZincException (String ("bbox Failed count=") + itos(count), + __FILE__, __LINE__); + } + z_tcl_call (Tcl_GetDoubleFromObj (interp, list[0], &_bbox[0]), + "bbox Failed"); + z_tcl_call (Tcl_GetDoubleFromObj (interp, list[1], &_bbox[1]), + "bbox Failed"); + z_tcl_call (Tcl_GetDoubleFromObj (interp, list[2], &_bbox[2]), + "bbox Failed"); + z_tcl_call (Tcl_GetDoubleFromObj (interp, list[3], &_bbox[3]), + "bbox Failed"); +} + + +/** + * Get the bounding box of an item in its parent group + * + * @param item the item to get bbox in its parent group + * @param bbox a table where we'll put the bounding box + * bbox[0] = x0, bbox[1] = y0, bbox[2] = xc, bbox[3] = yc + */ +void Zinc::relativeBbox (ZincItem* item, double _bbox[4]) +{ + //1) get bounding bbox + double tempBbox[4]; + this->bbox (item, tempBbox); + + //2) call transform + Tcl_Obj* tmp; + Tcl_Obj** list; + int count; + //discard old results + Tcl_ResetResult (interp); + // call .zinc transform device parentGroup {_bbox[0] _bbox[1] _bbox[2] _bbox[3]} + p1[0] = id; + p1[1] = ZFCT_transform; + p1[2] = ZFCT_device; + p1[3] = item->object; + + //coordinates as a list + p2[0] = Z_DBL_POOL (0, tempBbox[0]); + p2[1] = Z_DBL_POOL (1, tempBbox[1]); + p2[2] = Z_DBL_POOL (2, tempBbox[2]); + p2[3] = Z_DBL_POOL (3, tempBbox[3]); + p1[4] = Z_LST_POOL (4, p2, 4); + + // call the function with 5 arguments + z_command (5, "relativeBbox z_command Failed : "); + //free the list in pool No 4 + Z_CLEANLIST (4); + + //retreive the result as a list + tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_ListObjGetElements (interp, tmp, &count, &list), + "relativeBbox z_tcl_call Failed : "); + + //3) extract 4 double from the list + if (count != 4) + { + throw ZincException (String ("relativeBbox Failed count=") + itos(count), + __FILE__, __LINE__); + } + z_tcl_call (Tcl_GetDoubleFromObj (interp, list[0], &_bbox[0]), + "relativeBbox Failed"); + z_tcl_call (Tcl_GetDoubleFromObj (interp, list[1], &_bbox[1]), + "relativeBbox Failed"); + z_tcl_call (Tcl_GetDoubleFromObj (interp, list[2], &_bbox[2]), + "relativeBbox Failed"); + z_tcl_call (Tcl_GetDoubleFromObj (interp, list[3], &_bbox[3]), + "bbox Failed"); +} + + + + +/** + * Change the group of an item + * + * @param item the item to move + * @param parentGroup new group for the item + */ +void Zinc::chggroup (ZincItem *item, ZincItem *parentGroup) +{ + // call .zinc chggroup item parentGroup + p1[0] = id; + p1[1] = ZFCT_chggroup; + p1[2] = item->object; + p1[3] = Z_PARENTGROUP (parentGroup); + // call the function with 4 arguments + z_command (4, "chggroup Failed : "); +} + +/** + * Clone an item + * + * @param item the item to clone + * @return the cloned item + */ +ZincItem* Zinc::clone (ZincItem *item) +{ + // call .zinc clone item + p1[0] = id; + p1[1] = ZFCT_clone; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "clone Failed: "); + + //retreive the result as a tcl_obj + return new ZincItem (Tcl_GetObjResult (interp)); +} + +/** + * Get the number of contour of an item + * + * @return number of contour + */ +int Zinc::contour (ZincItem *item) +{ + Tcl_Obj* tmp; + int result; + // call .zinc contour item + p1[0] = id; + p1[1] = ZFCT_contour; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "contour Failed: "); + + //retreive the result as an int + tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &result), + "contour Failed: "); + return result; +} + +/** + * Set the contour of an item to the one of an other + * + * @param item the item on which we set the contour + * @param flag the operation to do on the contour + * @param reference the item to set contour from + * @return the number of contour + */ +int Zinc::contour (ZincItem *item, itemOperator flag, ZincItem *reference) +{ + Tcl_Obj* tmp; + int result; + //discard old results + Tcl_ResetResult (interp); + // call .zinc contour item flag reference + p1[0] = id; + p1[1] = ZFCT_contour; + p1[2] = item->object; + + //different possible actions depending on the flag + switch (flag) + { + case item_add_clockwise: + p1[3] = ZFCT_add; + p1[4] = Z_INT_POOL (0, -1); //add clockwise (-1) + break; + case item_add_counterclockwise: + p1[3] = ZFCT_add; + p1[4] = Z_INT_POOL (0, 1); //add counterclockwise (1) + break; + default: + p1[3] = ZFCT_remove; + p1[4] = Z_INT_POOL (0, 0); //no meaning (0) + } + // contour index (0) + p1[5] = Z_INT_POOL (1, 0); + // item reference + p1[6] = reference->object; + + // call the function with 7 arguments + z_command (7, "contour Failed: "); + + // retreive the result as an int + tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &result), + "contour Failed: "); + return result; +} + +/** + * Set the contour of an item + * + * @param item the item on which we set the contour + * @param add true to add a path, false to remove + * @param reference the new contour + * @return the number of contour + */ +int Zinc::contour (ZincItem *item, bool add, ZincPath *_contour) +{ + Tcl_Obj* tmp; + int result; + //discard old results + Tcl_ResetResult (interp); + // call .zinc contour item flag contour + p1[0] = id; + p1[1] = ZFCT_contour; + p1[2] = item->object; + + //different possible actions depending on the add flag + if (add) + { + p1[3] = ZFCT_add; + p1[4] = Z_INT_POOL (0, 0); //add contour (0) + } + else + { + p1[3] = ZFCT_remove; + p1[4] = Z_INT_POOL (0, 0); //no meaning (0) + } + // contour index + p1[5] = Z_INT_POOL (1, 0); + //contour + p1[6] = _contour->getTable (); + + // call the function with 7 arguments + z_command (7, "contour Failed: "); + + // retreive the result as an integer + tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &result), + "contour Failed: "); + return result; +} + +/** + * Set or modify the coordinates of an item + * + * @param item the item to modify + * @param contour new coords for the item + * @param add true to add coords, false to replace + * @param contourIndex the contour do modify + * @param coordIndex the coordinate to modify (WARNING, path must be one + * point if the is not the default) + */ +void Zinc::coords (ZincItem *item, ZincPath *_contour, bool add, + int contourIndex, int coordIndex) +{ + int i; + // call .zinc contour item ?flag? ?contourIndex? ?coordIndex? _contour + p1[0] = id; + p1[1] = ZFCT_coords; + p1[2] = item->object; + + // use i as a variable index for parameters + i = 3; // last parameter is p1[2] + // do we add or not + if (add) + { + p1[i++] = ZFCT_add; + } + + //ith there a contour + if (contourIndex != -1) + { + p1[i++] = Z_INT_POOL (1, contourIndex); + + //is there a coord index + if (coordIndex != -1) + { + p1[i++] = Z_INT_POOL (1, coordIndex); + } + } + + p1[i++] = _contour->getTable (); + + // call the function with i arguments + z_command (i, "coords Failed: "); +} + +/** + * Remove coords of an item + * + * @param item the item to modify + * @param coordIndex the coordinate to rmove + * @param contourIndex the contour on which we remove + */ +void Zinc::coordsRemove (ZincItem *item, int coordIndex, int contourIndex) +{ + int i; + // call .zinc coords item remove ?contourIndex? + p1[0] = id; + p1[1] = ZFCT_coords; + p1[2] = item->object; + p1[3] = ZFCT_remove; + + i = 4; + // is there a contourIndex + if (contourIndex != -1) + { + p1[i++] = Z_INT_POOL (1, contourIndex); + } + p1[i++] = Z_INT_POOL (1, coordIndex); + + // call the function with i arguments + z_command (i, "coordsRemove Failed: "); +} + +/** + * Add a tag to an item + * + * @param item the item to add tag to + * @param tag a tag to add + */ +void Zinc::addTag (ZincItem *item, String tag) +{ + // call .zinc addtag tag withtag + p1[0] = id; + p1[1] = ZFCT_addtag; + p1[2] = Z_STR_POOL (0, tag.c_str (), tag.length ()); + p1[3] = ZITM_withtag; + p1[4] = item->object; + // call the function with 5 arguments + z_command (5, "addTag Failed: "); +} + +/** + * Remove a tag from an item + * + * @param item the item to remove tag from + * @param tag a tag to remove + */ +void Zinc::dTag (ZincItem *item, String tag) +{ + // call .zinc dtag item tag + p1[0] = id; + p1[1] = ZFCT_dtag; + p1[2] = item->object; + + int i = 3; + //create a tg if nexessary + if (tag != "") + { + p1[i++] = Z_STR_POOL (0, tag.c_str (), tag.length ()); + } + + // call the function with i arguments + z_command (i, "dTag Failed: "); +} + +/** + * List all tags of an item + * It's up to the caller to delete the resulting table + * + * @param item the item to list tag from + * @param lagList a pointer to a table of String containing tags + * @return the number of tags + */ +int Zinc::getTags (ZincItem *item, String*** tagList) +{ + Tcl_Obj* tmp; + Tcl_Obj** list; + int count; + + //discard old results + Tcl_ResetResult (interp); + // call .zinc gettags item + p1[0] = id; + p1[1] = ZFCT_gettags; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "getTags Failed : "); + + //retreive the result as a list + tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_ListObjGetElements (interp, tmp, &count, &list), + "bbox Failed : "); + + // put strings into a new table + char *str; + //store the table into tagList + (*tagList) = new String* [count]; + + // fill the table + for (int i (0) ; i < count ; i++) + { + str = Tcl_GetString (list[i]); + (*tagList)[i] = new String (str); + } + return count; +} + +/** + * Set the focus to an item + * + * @param item the item to set the focus to + */ +void Zinc::focus (ZincItem *item) +{ + // .zinc focus item + p1[0] = id; + p1[1] = ZFCT_focus; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "focus Failed: "); +} + +/** + * Tell if the name is a gradient name + * + * @param gname a gradient name + * @return true if the name is a gradient name, false otherwise + */ +bool Zinc::isGname (String _gname) +{ + Tcl_Obj* tmp; + int result; + //discard old results + Tcl_ResetResult (interp); + // call .zinc gname _gname + p1[0] = id; + p1[1] = ZFCT_gname; + p1[2] = Z_STR_POOL (0, _gname.c_str (), _gname.length ()); + // call the function with 3 arguments + z_command (3, "isGname Failed: "); + + //retreive the result as a boolean + tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &result), + "isGname Failed: "); + return bool (result); +} + +/** + * Create a named gradient + * + * @param gradient a gradient + * @param gname a gradient name + */ +void Zinc::gname (String gradient, String _gname) +{ + // call .zinc gname gradient gname + p1[0] = id; + p1[1] = ZFCT_gname; + p1[2] = Z_STR_POOL (0, gradient.c_str (), gradient.length ()); + p1[3] = Z_STR_POOL (1, _gname.c_str (), _gname.length ()); + // call the function with 4 arguments + z_command (4, "gname Failed: "); +} + +/** + * Retreive the group of an item + * + * @param item the item to get the group from + * @return the group + */ +ZincItem* Zinc::group (ZincItem *item) +{ + Tcl_Obj* tmp; + //discard old results + Tcl_ResetResult (interp); + // call .zinc group item + p1[0] = id; + p1[1] = ZFCT_group; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "group Failed: "); + + //retreive the result as a tcl_obj + tmp = Tcl_GetObjResult (interp); + return new ZincItem (tmp); +} + +/** + * Reorder items to lower one + * + * @param item the item to lower + */ +void Zinc::lower (ZincItem *item) +{ + // call .zinc lower item + p1[0] = id; + p1[1] = ZFCT_lower; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "lower Failed: "); +} + +/** + * Reorder items to lower one + * + * @param item the item to lower + * @param belowThis and item that will be over item + */ +void Zinc::lower (ZincItem *item, ZincItem *belowThis) +{ + // call .zinc lower item belowThis + p1[0] = id; + p1[1] = ZFCT_lower; + p1[2] = item->object; + p1[3] = belowThis->object; + // call the function with 4 arguments + z_command (4, "lower Failed: "); +} + +/** + * Reorder items to raise one + * + * @param item the item to raise + */ +void Zinc::raise (ZincItem *item) +{ + // call .zinc raise item + p1[0] = id; + p1[1] = ZFCT_raise; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "raise Failed: "); +} + +/** + * Reorder items to raise one + * + * @param item the item to raise + * @param aboveThis an item that will be under item + */ +void Zinc::raise (ZincItem *item, ZincItem *aboveThis) +{ + // call .zinc raise item aboveThis + p1[0] = id; + p1[1] = ZFCT_raise; + p1[2] = item->object; + p1[3] = aboveThis->object; + // call the function with 4 arguments + z_command (4, "raise Failed: "); +} + +/** + * Return the type of an item + * + * @param item an item + * @return the type of the item + */ +itemType Zinc::type (ZincItem *item) +{ + Tcl_Obj *tmp; + //discard old results + Tcl_ResetResult (interp); + // call .zinc type item + p1[0] = id; + p1[1] = ZFCT_type; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "type Failed: "); + + //retreive the result as a string + tmp = Tcl_GetObjResult (interp); + + // convert the string to the right enum value + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + itemTypeStrings, + "itemType", + 0, &value), + "type Failed : "); + return itemType (value); +} + +/** + * Create a Zinc Tag that can be used in place of any item + * for zinc functions that must be called using tagOrId + * + * @param tag the text of the tag + * @return a tag item + */ +ZincItem* Zinc::createTag(String tag) +{ + //just create an item + return new ZincItem (Tcl_NewStringObj (tag.c_str (), tag.length ())); +} + +/******************************************************* + ITEM MANIPULATION +*******************************************************/ +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ + +/** + * Suppress an item + * + * @param item the item to suppress + */ +void Zinc::itemRemove (ZincItem *item) +{ + //call .zinc remove item + p1[0] = id; + p1[1] = ZFCT_remove; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "itemRemove failed :"); +} + +/** + * Create a group item + * + * @param parentGroup group where we'll put the new group, if NULL we create + * in the defaults group + * @return the group item + */ +ZincItem *Zinc::itemCreateGroup (ZincItem *parentGroup) +{ + //call .zinc add group parentGroup + p1[0] = id; + p1[1] = ZFCT_add; + p1[2] = ZITM_group; + p1[3] = Z_PARENTGROUP (parentGroup); + // call the function with 4 arguments + z_command (4, "itemCreateGroup failed :"); + + return new ZincItem (Tcl_GetObjResult (interp)); +} + +/** + * Create a rectangle item + * + * @param parentGroup group where we'll put it + * @param x y width height the coordinates of the new rectangle + * @return the rectangle item + */ +ZincItem* Zinc::itemCreateRectangle (ZincItem *parentGroup, double x, double y, + double width, double height) +{ + //call .zinc add rectangle parentGroup {coords} + p1[0] = id; + p1[1] = ZFCT_add; + p1[2] = ZITM_rectangle; + p1[3] = Z_PARENTGROUP (parentGroup); + //coordinates as a list + p2[0] = Z_DBL_POOL (0, x); + p2[1] = Z_DBL_POOL (1, y); + p2[2] = Z_DBL_POOL (2, width + x); + p2[3] = Z_DBL_POOL (3, height + y); + p1[4] = Z_LST_POOL (4, p2, 4); // a list with 4 items + // call the function with 4 arguments + z_command (5, "itemCreateRectangle failed :"); + + //clear the list in the pool No 4 + Z_CLEANLIST (4); + + return new ZincItem (Tcl_GetObjResult (interp)); +} + +/** + * Create an arc item + * + * @param parentGroup group where we'll put it + * @param x y width height the coordinates of the new rectangle + * @return the arc item + */ +ZincItem *Zinc::itemCreateArc (ZincItem *parentGroup, double x, double y, + double width, double height) +{ + //call .zinc add arc parentGroup {coords} + p1[0] = id; + p1[1] = ZFCT_add; + p1[2] = ZITM_arc; + p1[3] = Z_PARENTGROUP (parentGroup); + //coordinates as a list + p2[0] = Z_DBL_POOL (0, x); + p2[1] = Z_DBL_POOL (1, y); + p2[2] = Z_DBL_POOL (2, width + x); + p2[3] = Z_DBL_POOL (3, height + y); + p1[4] = Z_LST_POOL (4, p2, 4); + // call the function with 5 arguments + z_command (5, "itemCreateArc failed :"); + + //clear the list in the pool No 4 to reuse it later + Z_CLEANLIST (4); + + return new ZincItem (Tcl_GetObjResult (interp)); +} + +/** + * Create a text item + * + * @param parentGroup group where we'll put it + * @return the text item + */ +ZincItem *Zinc::itemCreateText (ZincItem *parentGroup) +{ + //call .zinc add text parentGroup + p1[0] = id; + p1[1] = ZFCT_add; + p1[2] = ZITM_text; + p1[3] = Z_PARENTGROUP (parentGroup); + // call the function with 4 arguments + z_command (4, "itemCreateText failed :"); + + return new ZincItem (Tcl_GetObjResult (interp)); +} + +/** + * Create a curve item + * + * @param parentGroup group where we'll put it + * @param path the path to display + * @return the curve item + */ +ZincItem *Zinc::itemCreateCurve (ZincItem *parentGroup, ZincPath *path) +{ + Tcl_Obj *table; + table = path->getTable (); + //call .zinc add curve parentGroup {path} + p1[0] = id; + p1[1] = ZFCT_add; + p1[2] = ZITM_curve; + p1[3] = Z_PARENTGROUP (parentGroup); + p1[4] = table; + // call the function with 5 arguments + z_command (5, "itemCreateCurve failed :"); + return new ZincItem (Tcl_GetObjResult (interp)); +} + + +/** + * Create an icon item + * + * @param parentGroup group where we'll put it + * @param image a zincImage to display + * @return the icon item + */ +ZincItem *Zinc::itemCreateIcon (ZincItem *parentGroup, ZincImage* image) +{ + //call .zinc add icon parentGroup + p1[0] = id; + p1[1] = ZFCT_add; + p1[2] = ZITM_icon; + p1[3] = Z_PARENTGROUP (parentGroup); + // call the function with 4 arguments + z_command (4, "itemCreateIcon failed :"); + + //retreive the result + ZincItem *result = new ZincItem (Tcl_GetObjResult (interp)); + //to be able to set the image + itemSetImage (result, image); + + return result; +} + +/************************************************** + TRANSFORMATION METHODS +**************************************************/ + +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ + +/** + * Translate the item + * + * @param item the item to which we apply the transform + * @param dx dy translation vector + */ +void Zinc::itemTranslate (ZincItem * item, double dx, double dy) +{ + // call .zinc translate item dx dy + p1[0] = id; + p1[1] = ZFCT_translate; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, dx); + p1[4] = Z_DBL_POOL (1, dy); + // call the function with 5 arguments + z_command (5, "itemTranslateRelative Failed : "); +} + +/** + * Translate the item + * + * @param item the item to which we apply the transform + * @param x y translation vector + * @param absolute true if the translation is absolute + */ +void Zinc::itemTranslate (ZincItem * item, double x, double y, bool absolute) +{ + // call .zinc translate item x y absolute + p1[0] = id; + p1[1] = ZFCT_translate; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, x); + p1[4] = Z_DBL_POOL (1, y); + p1[5] = Z_BOO_POOL (2, absolute); + // call the function with 6 arguments + z_command (6, "itemTranslateAbsolute Failed : "); +} + +/** + * Rotate an item + * + * @param item the item to which we apply the transform + * @param angle the angle to rotate in radian + */ +void Zinc::itemRotate (ZincItem * item, double angle) +{ + // call .zinc rotate item angle + p1[0] = id; + p1[1] = ZFCT_rotate; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, angle); + // call the function with 4 arguments + z_command (4, "itemRotate (angle) Failed : "); +} + +/** + * Rotate an item + * + * @param item the item to which we apply the transform + * @param angle the angle to rotate in radian + * @param x y the center of the rotation + */ +void Zinc::itemRotate (ZincItem * item, double angle, double x, double y) +{ + // call .zinc rotate item angle x y + p1[0] = id; + p1[1] = ZFCT_rotate; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, angle); + p1[4] = Z_DBL_POOL (1, x); + p1[5] = Z_DBL_POOL (2, y); + // call the function with 6 arguments + z_command (6, "itemRotateDegree (angle,center) Failed : "); +} + +/** + * Rotate an item + * + * @param item the item to which we apply the transform + * @param angle the angle to rotate + * @param degree true for an angle in degree, false for an angle in radians + */ +void Zinc::itemRotate (ZincItem * item, double angle, bool degree) +{ + // call .zinc rotate item angle degree + p1[0] = id; + p1[1] = ZFCT_rotate; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, angle); + p1[4] = Z_BOO_POOL (1, degree); + // call the function with 5 arguments + z_command (5, "itemRotate (angle,degree) Failed : "); +} + +/** + * Rotate an item + * + * @param item the item to which we apply the transform + * @param angle the angle to rotate in radian + * @param x y the center of the rotation + * @param degree true for an angle in degree, false for an angle in radians + */ +void Zinc::itemRotate (ZincItem * item, double angle, double x, double y, + bool degree) +{ + // call .zinc rotate item angle degree x y + p1[0] = id; + p1[1] = ZFCT_rotate; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, angle); + p1[4] = Z_BOO_POOL (1, degree); + p1[5] = Z_DBL_POOL (2, x); + p1[6] = Z_DBL_POOL (3, y); + // call the function with 7 arguments + z_command (7, "itemRotate (angle,center,degree) Failed : "); +} + +/** + * Scale an item + * + * @param item the item to which we apply the transform + * @param ax horizontal scale + * @param ay vertical scale + */ +void Zinc::itemScale (ZincItem * item, double ax, double ay) +{ + // call .zinc scale item ax ay + p1[0] = id; + p1[1] = ZFCT_scale; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, ax); + p1[4] = Z_DBL_POOL (1, ay); + // call the function with 5 arguments + z_command (5, "itemScale Failed : "); +} + +/** + * Scale an item using a specified center + * + * @param item the item to which we apply the transform + * @param ax horizontal scale + * @param ay vertical scale + * @param cx cy center of the scale + */ +void Zinc::itemScale (ZincItem * item, double ax, double ay, double cx, double cy) +{ + // call .zinc scale item ax ay cx cy + p1[0] = id; + p1[1] = ZFCT_scale; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, ax); + p1[4] = Z_DBL_POOL (1, ay); + p1[5] = Z_DBL_POOL (2, cx); + p1[6] = Z_DBL_POOL (3, cy); + // call the function with 7 arguments + z_command (7, "itemScale (center) Failed : "); +} + +/** + * Skew an item + * + * @param item the item to which we apply the transform + * @param sx horizontal skew + * @param sy vertical skew + */ +void Zinc::itemSkew (ZincItem * item, double sx, double sy) +{ + // call .zinc skew item sx sy + p1[0] = id; + p1[1] = ZFCT_skew; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, sx); + p1[4] = Z_DBL_POOL (1, sy); + // call the function with 5 arguments + z_command (5, "itemSkew Failed : "); +} + +/** + * Skew an item horizontaly + * + * @param item the item to which we apply the transform + * @param sx horizontal skew + */ +void Zinc::itemSkewX (ZincItem * item, double sx) +{ + // call .zinc skew item sx 0 + p1[0] = id; + p1[1] = ZFCT_skew; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, sx); + p1[4] = Z_DBL_POOL (1, 0); + // call the function with 5 arguments + z_command (5, "itemSkewX Failed : "); +} + +/** + * Skew an item verticaly + * + * @param item the item to which we apply the transform + * @param sy vertical skew + */ +void Zinc::itemSkewY (ZincItem * item, double sy) +{ + // call .zinc skew item 0 sy + p1[0] = id; + p1[1] = ZFCT_skew; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, 0); + p1[4] = Z_DBL_POOL (1, sy); + // call the function with 5 arguments + z_command (5, "itemSkewY Failed : "); +} + +/** + * Reset all transformations associated with the item + * + * @param item the item to which we apply the transform + */ +void Zinc::itemResetTransformation (ZincItem * item) +{ + // call .zinc treset item + p1[0] = id; + p1[1] = ZFCT_treset; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "itemResetTransformation Failed : "); +} + +/** + * Replace current transform by a matrix + * + * @param item the item to which we apply the transform + * @param a,b,c,d,e,f the new transform matrix + */ +void Zinc::itemSetTransformation (ZincItem * item, + double a, double b, double c, + double d, double e, double f) +{ + // call .zinc tset item a b c d e f + p1[0] = id; + p1[1] = ZFCT_tset; + p1[2] = item->object; + p1[3] = Z_DBL_POOL (0, a); + p1[4] = Z_DBL_POOL (1, b); + p1[5] = Z_DBL_POOL (2, c); + p1[6] = Z_DBL_POOL (3, d); + p1[7] = Z_DBL_POOL (4, e); + p1[8] = Z_DBL_POOL (5, f); + // call the function with 9 arguments + z_command (9, "itemSetTransformation Failed : "); +} + +/** + * Get current transform matrix + * @param item the item to which we apply the transform + * @param a,b,c,d,e,f places where we'll put the transform matrix + */ +void Zinc::itemGetTransformation (ZincItem * item, + double *a, double *b, double *c, + double *d, double *e, double *f) +{ + // bug in zinc (or not?), it doesn't reset result for the tget function + // or apennd a result instead of replacing it + Tcl_ResetResult (interp); + // call .zinc tget item + p1[0] = id; + p1[1] = ZFCT_tget; + p1[2] = item->object; + // call the function with 3 arguments + z_command (3, "itemGetTransformation Failed : "); + + //retreive the result as a list object + Tcl_Obj* tmp = Tcl_GetObjResult (interp); + int num; + Tcl_Obj** elems; + z_tcl_call (Tcl_ListObjGetElements (interp, tmp, &num, &elems), + "itemGetTransformation Failed : "); + + //num is necessarily 6, extract 6 double + z_tcl_call (Tcl_GetDoubleFromObj(interp, elems[0], a), + "itemGetTransformation Failed : "); + z_tcl_call (Tcl_GetDoubleFromObj(interp, elems[1], b), + "itemGetTransformation Failed : "); + z_tcl_call (Tcl_GetDoubleFromObj(interp, elems[2], c), + "itemGetTransformation Failed : "); + z_tcl_call (Tcl_GetDoubleFromObj(interp, elems[3], d), + "itemGetTransformation Failed : "); + z_tcl_call (Tcl_GetDoubleFromObj(interp, elems[4], e), + "itemGetTransformation Failed : "); + z_tcl_call (Tcl_GetDoubleFromObj(interp, elems[5], f), + "itemGetTransformation Failed : "); +} + + +/** + * Multiply current transform by a matrix + * + * @param item the item to which we apply the transform + * @param a,b,c,d,e,f transform matrix + */ +void Zinc::itemMatrix (ZincItem * item, + double a, double b, double c, + double d, double e, double f) +{ + double a0,b0,c0,d0,e0,f0; + double a1,b1,c1,d1,e1,f1; + // get current transform + itemGetTransformation (item, &a0, &b0, &c0, &d0, &e0, &f0); + + //multiply + a1 = a * a0 + d * b0; + b1 = b * a0 + e * b0; + c1 = c * a0 + f * b0 + c0; + d1 = a * d0 + d * e0; + e1 = b * d0 + e * e0; + f1 = c * d0 + f * e0 + f0; + + // set to new transform + itemSetTransformation (item, a1, b1, c1, d1, e1, f1); +} + +/************************************************** + BINDING +**************************************************/ + +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ + +//number of elements in the ZincEvent structure +#define EVENT_COUNT 10 +//number of basic parameters to a widget callback +#define WIDGETCB_COUNT 3 +//number of basic parameters to an item callback +#define ITEMCB_COUNT 4 + +//the equivalent of z_tcl_call able to be called in a callback +#define z_tcl_call2(fct,msg) \ + { \ + int result = (fct); \ + if (result != TCL_OK) \ + { \ + Tcl_AppendResult (Zinc::interp, msg, NULL); \ + return TCL_ERROR; \ + } \ + } + +/** + * Real callback used by zinc TCL + * + * @param client_data the Zinc object + * @param interp current interpreter + * @param argc number of arguments + * @param args table of arguments + */ +int tclCallback (ClientData client_data, Tcl_Interp *interp, + int argc, Tcl_Obj *CONST args[]) +{ + Zinc *zinc = (Zinc*) client_data; + int cb; + ZincItem *item; + void *userData; + ZincEvent *ev; + long value; + + //count arguments + if ((argc != WIDGETCB_COUNT + EVENT_COUNT) && (argc != ITEMCB_COUNT + EVENT_COUNT)) + { + Tcl_SetResult (Zinc::interp, "Zinclib: Invalid argument count in tclCallback", NULL); + return TCL_ERROR; + } + // skip the bind name + args++; + + // get the item if this is an item bind + if (argc == ITEMCB_COUNT + EVENT_COUNT) + { + // retreive item + z_tcl_call2 (Tcl_GetLongFromObj (interp, args[0], &value), + "Zinclib: No item in tclCallback"); + item = (ZincItem*) value; + args++; + } + + // retreive callback + z_tcl_call2 (Tcl_GetLongFromObj (interp, args[0], &value), + "Zinclib: No callback in tclCallback"); + cb = value; + + // retreive userdata + args++; + z_tcl_call2 (Tcl_GetLongFromObj (interp, args[0], &value), + "Zinclib: No userData in tclCallback"); + userData = (void*) value; + + // point args to events values + args++; + //fill event structure with all avent values we support + ev = new ZincEvent; + // x position of the mouse + if (Tcl_GetIntFromObj (interp, args[0], &(ev->x)) != TCL_OK) + { + ev->x = 0; + } + // y position of the mouse + if (Tcl_GetIntFromObj (interp, args[1], &(ev->y)) != TCL_OK) + { + ev->y = 0; + } + // keycode + if (Tcl_GetIntFromObj (interp, args[2], &(ev->k)) != TCL_OK) + { + ev->k = 0; + } + // timestamp + if (Tcl_GetLongFromObj (interp, args[3], &(ev->t)) != TCL_OK) + { + ev->t = 0; + } + // keysyms + ev->K = String (Tcl_GetString (args[4])); + // window height + if (Tcl_GetIntFromObj (interp, args[5], &(ev->h)) != TCL_OK) + { + ev->h = 0; + } + // window width + if (Tcl_GetIntFromObj (interp, args[6], &(ev->w)) != TCL_OK) + { + ev->w = 0; + } + // x position of the mouse within display + if (Tcl_GetIntFromObj (interp, args[7], &(ev->X)) != TCL_OK) + { + ev->X = 0; + } + // y position of the mouse within display + if (Tcl_GetIntFromObj (interp, args[8], &(ev->Y)) != TCL_OK) + { + ev->Y = 0; + } + // button pressed + if (Tcl_GetIntFromObj (interp, args[9], &(ev->b)) != TCL_OK) + { + ev->b = 0; + } + + // Call the callback + if (argc == ITEMCB_COUNT + EVENT_COUNT) + { + // this is a callback on an item + ZincItemCallback itemCb = (ZincItemCallback)cb; + (*itemCb) (zinc, item, ev, userData); + } + else + { + // this is a callback on the zinc widget + ZincWidgetCallback zincCb = (ZincWidgetCallback)cb; + (*zincCb) (zinc, ev, userData); + } + + delete ev; + return TCL_OK; +} + +/** + * Bind a function to an event on the zinc widget + * + * @param eventSpecification tcl style event specicication + * @param callBack the function which will be called back + * @param userData data we will give back to the callback when called + * @param add false to replace existing bind or true to add + */ +void Zinc::bind (String eventSpecification, + ZincWidgetCallback callBack, void *userData, bool add) +{ + // call bind .zinc eventSpec script + const char* para[4]; + para[0] = "bind"; + para[1] = window.c_str (); + para[2] = eventSpecification.c_str (); + + //create callback script + // this script is a call to the tclCallback function using all arguments we need + String script; + // do we add or replace the callback + if (add) + { + script = String("+"); + } + script += tclCb + " "; // name of the tcl function we created + script += ltos ((long)callBack) + " "; // the real callback (as a pointer) + script += ltos ((long)userData) + " "; // the user data (as a pointer) + script += "%x %y %k %t %K %h %w %X %Y %b";// arguments for the event structure + para[3] = script.c_str (); + + //call the command with 4 arguments + z_tcl_call ((*bndCmdInfo.proc)(bndCmdInfo.clientData, interp, 4, para), + "bind Failed : "); +} + +/** + * Annulate a binding + * + * @param eventSpecification tcl style event specicication + */ +void Zinc::unbind (String eventSpecification) +{ + // call bind .zinc eventSpec "" + const char* para[4];; + para[0] = "bind"; + para[1] = window.c_str (); + para[2] = eventSpecification.c_str (); + para[3] = ""; + + //call the command with 4 arguments + z_tcl_call ((*bndCmdInfo.proc)(bndCmdInfo.clientData, interp, 4, para), + "unbind Failed : "); +} + +/** + * Bind a function to an event on an item + * + * @param item the item on which to bind + * @param eventSpecification tcl style event specicication + * @param callBack the function which will be called back + * @param userData data we will give back to the callback when called + */ +void Zinc::itemBind (ZincItem *item, String eventSpec, + ZincItemCallback callBack, void *userData, bool add) +{ + // call .zinc bind item eventSpec script + p1[0] = id; + p1[1] = ZFCT_bind; + p1[2] = item->object; + p1[3] = Z_STR_POOL (0, eventSpec.c_str (), eventSpec.length ()); + + //create callback script + // this script is a call to the tclCallback function using all arguments we need + String script; + // do we add or replace the callback + if (add) + { + script = String("+"); + } + script += tclCb + " "; // name of the tcl function we created + script += ltos ((long)item) + " "; // the item (as a pointer) + script += ltos ((long)callBack) + " "; // the real callback (as a pointer) + script += ltos ((long)userData) + " "; // the user data (as a pointer) + script += "%x %y %k %t %K %h %w %X %Y %b"; // arguments for the event structure + p1[4] = Z_STR_POOL (1, script.c_str (), script.length ()); + + // call the widget command with 5 arguments + z_command (5, "itemBind Failed : "); +} + +/** + * Annulate a binding + * + * @param item the item on which to unbind + * @param eventSpecification tcl style event specicication + */ +void Zinc::itemUnbind (ZincItem *item, String eventSpec) +{ + // call .zinc bind item eventSpec "" + p1[0] = id; + p1[1] = ZFCT_bind; + p1[2] = item->object; + p1[3] = Z_STR_POOL (0, eventSpec.c_str (), eventSpec.length ()); + p1[4] = Z_STR_POOL (1, "", -1); + + //call the command with 5 arguments + z_command (5, "itemUnbind Failed : "); +} + +/******************************************************* + STATIC PROCEDURES +*******************************************************/ + +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ + +/** + * Loads the zinc library and initialize tcl and tk + * + * @param argv0 the name of the executable as passed in argv[0] + */ +void Zinc::loadZinc (char *argv0) throw (ZincException) +{ + //Initialise internal TCL structure + Tcl_FindExecutable (argv0); + //Create an interpreter + interp = Tcl_CreateInterp(); + if (interp == NULL) + { + throw ZincException("Tcl_CreateInterp Error", __FILE__, __LINE__); + } + + // set display + Tcl_SetVar(interp, "env", "DISPLAY", TCL_GLOBAL_ONLY); + //remove prompt + Tcl_SetVar(interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY); + + // needed for Default system startup file for Tcl-based applications + z_tcl_call (Tcl_Init(interp), "Tcl_Init failed : "); + + //Initialize Tk +// Tk_Init(interp); + + z_tcl_call (Tk_Init (interp), "Tk_Init failed : "); + + //Initialize Zinc + z_tcl_call (Tkzinc_Init (interp), "Tkzinc_Init failed :"); + + // Load Img package in order to handle PNG, JPEG, .. + z_tcl_call (Tcl_GlobalEval (interp, "package require Img"), "Package Img not found"); + + //Initialize objects pool + for (int i(0); i<ZINC_POOL_COUNT ; i++) + { + pool[i] = Tcl_NewObj (); + Tcl_IncrRefCount (pool[i]); + } + + //initialise frame command info + if (!Tcl_GetCommandInfo(interp, "toplevel", &topCmdInfo)) + { + throw ZincException (String ("Toplevel command not found"), + __FILE__, __LINE__); + } + + //initialise zinc command info + if (!Tcl_GetCommandInfo(interp, "zinc", &zncCmdInfo)) + { + throw ZincException (String ("Zinc command not found"), + __FILE__, __LINE__); + } + + //initialise image command info + if (!Tcl_GetCommandInfo(interp, "image", &imgCmdInfo)) + { + throw ZincException (String ("Image command not found"), + __FILE__, __LINE__); + } + + //initialise font command info + if (!Tcl_GetCommandInfo(interp, "font", &fntCmdInfo)) + { + throw ZincException (String ("Font command not found"), + __FILE__, __LINE__); + } + + //initialise focus command info + if (!Tcl_GetCommandInfo(interp, "focus", &focCmdInfo)) + { + throw ZincException (String ("Focus command not found"), + __FILE__, __LINE__); + } + + //initialise bind command info + if (!Tcl_GetCommandInfo(interp, "bind", &bndCmdInfo)) + { + throw ZincException (String ("Bind command not found"), + __FILE__, __LINE__); + } +} + + +/** + * Run tk mainloop and returns when there is no more Tk window + */ +void Zinc::zincMainLoop () +{ + Tk_MainLoop(); +} + + +/******************************************************* + AUTOGENERATED METHODS (itemconfigure) +"code.cpp" in Tkzins/generic source from : + ./gen.pl Arc.c Attrs.c Color.c Curve.c Draw.c Group.c + Image.c List.c Item.c Icon.c Rectangle.c tkZinc.c Text.c +*******************************************************/ + +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ + +/** + * Call zinc->itemconfigure ( -closed ) + * + * @param item the item to configure + * @param value the closed to set + */ +void Zinc::itemSetClosed (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_closed; + p1[4] = Z_BOO_POOL (1, value); + + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetClosed Failed : "); +} + +/** + * Call zinc->itemcget ( -closed ) + * + * @param item the item to get closed from + * @return closed value + */ +bool Zinc::itemGetClosed (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_closed; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetClosed Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetClosed Failed : "); + return bool (value); +} + +/** + * Call zinc->itemconfigure ( -composealpha ) + * + * @param item the item to configure + * @param value the composealpha to set + */ +void Zinc::itemSetComposealpha (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_composealpha; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetComposealpha Failed : "); +} + +/** + * Call zinc->itemcget ( -composealpha ) + * + * @param item the item to get composealpha from + * @return composealpha value + */ +bool Zinc::itemGetComposealpha (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_composealpha; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetComposealpha Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetComposealpha Failed : "); + return bool (value); +} + +/** + * Call zinc->itemconfigure ( -composerotation ) + * + * @param item the item to configure + * @param value the composerotation to set + */ +void Zinc::itemSetComposerotation (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_composerotation; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetComposerotation Failed : "); +} + +/** + * Call zinc->itemcget ( -composerotation ) + * + * @param item the item to get composerotation from + * @return composerotation value + */ +bool Zinc::itemGetComposerotation (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_composerotation; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetComposerotation Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetComposerotation Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -composescale ) + * + * @param item the item to configure + * @param value the composescale to set + */ +void Zinc::itemSetComposescale (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_composescale; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetComposescale Failed : "); +} + +/** + * Call zinc->itemcget ( -composescale ) + * + * @param item the item to get composescale from + * @return composescale value + */ +bool Zinc::itemGetComposescale (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_composescale; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetComposescale Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetComposescale Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -extent ) + * + * @param item the item to configure + * @param value the extent to set + */ +void Zinc::itemSetExtent (ZincItem * item, unsigned int value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_extent; + p1[4] = Z_INT_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetExtent Failed : "); +} + +/** + * Call zinc->itemcget ( -extent ) + * + * @param item the item to get extent from + * @return extent value + */ +unsigned int Zinc::itemGetExtent (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_extent; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetExtent Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "itemGetExtent Failed : "); + return (unsigned int)value; +} + +/** + * Call zinc->itemconfigure ( -fillcolor ) + * + * @param item the item to configure + * @param value the fillcolor to set + */ +void Zinc::itemSetFillcolor (ZincItem * item, String value) +{ + //Warning, weird bug workaround + // here is a deep copy + // without this, on frequent calls, tcl mays segfault + String tmp = String(value.c_str ()); + + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_fillcolor; + p1[4] = Z_STR_POOL (1, tmp.c_str (), -1); + //call the zinc function in with 5 arguments internal form + z_command (5, "itemSetFillcolor Failed : "); +} + +/** + * Call zinc->itemcget ( -fillcolor ) + * + * @param item the item to get fillcolor from + * @return fillcolor value + */ +String Zinc::itemGetFillcolor (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_fillcolor; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetFillcolor Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return String (Tcl_GetStringFromObj (tmp, NULL)); +} + +/** + * Call zinc->itemconfigure ( -filled ) + * + * @param item the item to configure + * @param value the filled to set + */ +void Zinc::itemSetFilled (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_filled; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetFilled Failed : "); +} + +/** + * Call zinc->itemcget ( -filled ) + * + * @param item the item to get filled from + * @return filled value + */ +bool Zinc::itemGetFilled (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_filled; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetFilled Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetFilled Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -fillpattern ) + * + * @param item the item to configure + * @param value the fillpattern to set + */ +void Zinc::itemSetFillpattern (ZincItem * item, ZincBitmap *value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_fillpattern; + p1[4] = value->object; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetFillpattern Failed : "); +} + +/** + * Call zinc->itemcget ( -fillpattern ) + * + * @param item the item to get fillpattern from + * @return fillpattern value + */ +ZincBitmap * Zinc::itemGetFillpattern (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_fillpattern; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetFillpattern Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return new ZincBitmap (tmp, true); +} + +/** + * Call zinc->itemconfigure ( -linecolor ) + * + * @param item the item to configure + * @param value the linecolor to set + */ +void Zinc::itemSetLinecolor (ZincItem * item, String value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_linecolor; + p1[4] = Z_STR_POOL (1, value.c_str (), value.length ()); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetLinecolor Failed : "); +} + +/** + * Call zinc->itemcget ( -linecolor ) + * + * @param item the item to get linecolor from + * @return linecolor value + */ +String Zinc::itemGetLinecolor (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_linecolor; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetLinecolor Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return String (Tcl_GetStringFromObj (tmp, NULL)); +} + +/** + * Call zinc->itemconfigure ( -linepattern ) + * + * @param item the item to configure + * @param value the linepattern to set + */ +void Zinc::itemSetLinepattern (ZincItem * item, ZincBitmap * value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_linepattern; + p1[4] = value->object; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetLinepattern Failed : "); +} + +/** + * Call zinc->itemcget ( -linepattern ) + * + * @param item the item to get linepattern from + * @return linepattern value + */ +ZincBitmap * Zinc::itemGetLinepattern (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_linepattern; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetLinepattern Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return new ZincBitmap (tmp, true); +} + +/** + * Call zinc->itemconfigure ( -linestyle ) + * + * @param item the item to configure + * @param value the linestyle to set + */ +void Zinc::itemSetLinestyle (ZincItem * item, lineStyle value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_linestyle; + p1[4] = lineStyles[value]; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetLinestyle Failed : "); +} + +/** + * Call zinc->itemcget ( -linestyle ) + * + * @param item the item to get linestyle from + * @return linestyle value + */ +lineStyle Zinc::itemGetLinestyle (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_linestyle; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetLinestyle Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + lineStylesStrings, + "lineStyles", + 0, &value), + "itemGetLinestyle Failed : "); + return (lineStyle)value; +} + +/** + * Call zinc->itemconfigure ( -linewidth ) + * + * @param item the item to configure + * @param value the linewidth to set + */ +void Zinc::itemSetLinewidth (ZincItem * item, double value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_linewidth; + p1[4] = Z_DBL_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetLinewidth Failed : "); +} + +/** + * Call zinc->itemcget ( -linewidth ) + * + * @param item the item to get linewidth from + * @return linewidth value + */ +double Zinc::itemGetLinewidth (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_linewidth; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetLinewidth Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + double value; + z_tcl_call (Tcl_GetDoubleFromObj (interp, tmp, &value), + "itemGetLinewidth Failed : "); + return (double)value; +} + +/** + * Call zinc->itemconfigure ( -pieslice ) + * + * @param item the item to configure + * @param value the pieslice to set + */ +void Zinc::itemSetPieslice (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_pieslice; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetPieslice Failed : "); +} + +/** + * Call zinc->itemcget ( -pieslice ) + * + * @param item the item to get pieslice from + * @return pieslice value + */ +bool Zinc::itemGetPieslice (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_pieslice; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetPieslice Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetPieslice Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -priority ) + * + * @param item the item to configure + * @param value the priority to set + */ +void Zinc::itemSetPriority (ZincItem * item, unsigned int value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_priority; + p1[4] = Z_INT_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetPriority Failed : "); +} + +/** + * Call zinc->itemcget ( -priority ) + * + * @param item the item to get priority from + * @return priority value + */ +unsigned int Zinc::itemGetPriority (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_priority; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetPriority Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "itemGetPriority Failed : "); + return (unsigned int)value; +} + +/** + * Call zinc->itemconfigure ( -sensitive ) + * + * @param item the item to configure + * @param value the sensitive to set + */ +void Zinc::itemSetSensitive (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_sensitive; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetSensitive Failed : "); +} + +/** + * Call zinc->itemcget ( -sensitive ) + * + * @param item the item to get sensitive from + * @return sensitive value + */ +bool Zinc::itemGetSensitive (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_sensitive; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetSensitive Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetSensitive Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -startangle ) + * + * @param item the item to configure + * @param value the startangle to set + */ +void Zinc::itemSetStartangle (ZincItem * item, unsigned int value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_startangle; + p1[4] = Z_INT_POOL (1, value); + //call the zinc function with 5 argumentsin internal form + z_command (5, "itemSetStartangle Failed : "); +} + +/** + * Call zinc->itemcget ( -startangle ) + * + * @param item the item to get startangle from + * @return startangle value + */ +unsigned int Zinc::itemGetStartangle (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_startangle; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetStartangle Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "itemGetStartangle Failed : "); + return (unsigned int)value; +} + +/** + * Call zinc->itemconfigure ( -tile ) + * + * @param item the item to configure + * @param value the tile to set + */ +void Zinc::itemSetTile (ZincItem * item, ZincBitmap * value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_tile; + p1[4] = value->object; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetTile Failed : "); +} + +/** + * Call zinc->itemcget ( -tile ) + * + * @param item the item to get tile from + * @return tile value + */ +ZincBitmap * Zinc::itemGetTile (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_tile; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetTile Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return new ZincBitmap (tmp, true); +} + +/** + * Call zinc->itemconfigure ( -visible ) + * + * @param item the item to configure + * @param value the visible to set + */ +void Zinc::itemSetVisible (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_visible; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetVisible Failed : "); +} + +/** + * Call zinc->itemcget ( -visible ) + * + * @param item the item to get visible from + * @return visible value + */ +bool Zinc::itemGetVisible (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_visible; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetVisible Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetVisible Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -capstyle ) + * + * @param item the item to configure + * @param value the capstyle to set + */ +void Zinc::itemSetCapstyle (ZincItem * item, capStyle value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_capstyle; + p1[4] = capStyles[value]; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetCapstyle Failed : "); +} + +/** + * Call zinc->itemcget ( -capstyle ) + * + * @param item the item to get capstyle from + * @return capstyle value + */ +capStyle Zinc::itemGetCapstyle (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_capstyle; + //call the zinc function with 4 argumentsin internal form + z_command (4, "itemGetCapstyle Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + capStylesStrings, + "capStyles", + 0, &value), + "itemGetCapstyle Failed : "); + return (capStyle)value; +} + +/** + * Call zinc->itemconfigure ( -fillrule ) + * + * @param item the item to configure + * @param value the fillrule to set + */ +void Zinc::itemSetFillrule (ZincItem * item, fillRule value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_fillrule; + p1[4] = fillRules[value]; + //call the zinc function with 5 argumentsin internal form + z_command (5, "itemSetFillrule Failed : "); +} + +/** + * Call zinc->itemcget ( -fillrule ) + * + * @param item the item to get fillrule from + * @return fillrule value + */ +fillRule Zinc::itemGetFillrule (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_fillrule; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetFillrule Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + fillRulesStrings, + "fillRules", + 0, &value), + "itemGetFillrule Failed : "); + return (fillRule)value; +} + +/** + * Call zinc->itemconfigure ( -joinstyle ) + * + * @param item the item to configure + * @param value the joinstyle to set + */ +void Zinc::itemSetJoinstyle (ZincItem * item, joinStyle value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_joinstyle; + p1[4] = joinStyles[value]; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetJoinstyle Failed : "); +} + +/** + * Call zinc->itemcget ( -joinstyle ) + * + * @param item the item to get joinstyle from + * @return joinstyle value + */ +joinStyle Zinc::itemGetJoinstyle (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_joinstyle; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetJoinstyle Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + joinStylesStrings, + "joinStyles", + 0, &value), + "itemGetJoinstyle Failed : "); + return (joinStyle)value; +} + +/** + * Call zinc->itemconfigure ( -relief ) + * + * @param item the item to configure + * @param value the relief to set + */ +void Zinc::itemSetRelief (ZincItem * item, relief value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_relief; + p1[4] = reliefs[value]; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetRelief Failed : "); +} + +/** + * Call zinc->itemcget ( -relief ) + * + * @param item the item to get relief from + * @return relief value + */ +relief Zinc::itemGetRelief (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_relief; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetRelief Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + reliefsStrings, + "reliefs", + 0, &value), + "itemGetRelief Failed : "); + return (relief)value; +} + +/** + * Call zinc->itemconfigure ( -smoothrelief ) + * + * @param item the item to configure + * @param value the smoothrelief to set + */ +void Zinc::itemSetSmoothrelief (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_smoothrelief; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetSmoothrelief Failed : "); +} + +/** + * Call zinc->itemcget ( -smoothrelief ) + * + * @param item the item to get smoothrelief from + * @return smoothrelief value + */ +bool Zinc::itemGetSmoothrelief (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_smoothrelief; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetSmoothrelief Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetSmoothrelief Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -alpha ) + * + * @param item the item to configure + * @param value the alpha to set + */ +void Zinc::itemSetAlpha (ZincItem * item, unsigned int value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_alpha; + p1[4] = Z_INT_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetAlpha Failed : "); +} + +/** + * Call zinc->itemcget ( -alpha ) + * + * @param item the item to get alpha from + * @return alpha value + */ +unsigned int Zinc::itemGetAlpha (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_alpha; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetAlpha Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "itemGetAlpha Failed : "); + return (unsigned int)value; +} + +/** + * Call zinc->itemconfigure ( -atomic ) + * + * @param item the item to configure + * @param value the atomic to set + */ +void Zinc::itemSetAtomic (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_atomic; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function in with 5 arguments internal form + z_command (5, "itemSetAtomic Failed : "); +} + +/** + * Call zinc->itemcget ( -atomic ) + * + * @param item the item to get atomic from + * @return atomic value + */ +bool Zinc::itemGetAtomic (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_atomic; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetAtomic Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetAtomic Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -clip ) + * + * @param item the item to configure + * @param value the clip to set + */ +void Zinc::itemSetClip (ZincItem * item, ZincItem * value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_clip; + p1[4] = value->object; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetClip Failed : "); +} + +/** + * Call zinc->itemcget ( -clip ) + * + * @param item the item to get clip from + * @return clip value + */ +ZincItem * Zinc::itemGetClip (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_clip; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetClip Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return new ZincItem(tmp); +} + +/** + * Call zinc->itemconfigure ( -anchor ) + * + * @param item the item to configure + * @param value the anchor to set + */ +void Zinc::itemSetAnchor (ZincItem * item, anchor value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_anchor; + p1[4] = anchors[value]; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetAnchor Failed : "); +} + +/** + * Call zinc->itemcget ( -anchor ) + * + * @param item the item to get anchor from + * @return anchor value + */ +anchor Zinc::itemGetAnchor (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_anchor; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetAnchor Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + anchorsStrings, + "anchors", + 0, &value), + "itemGetAnchor Failed : "); + return (anchor)value; +} + +/** + * Call zinc->itemconfigure ( -color ) + * + * @param item the item to configure + * @param value the color to set + */ +void Zinc::itemSetColor (ZincItem * item, String value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_color; + p1[4] = Z_STR_POOL (1, value.c_str (), value.length ()); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetColor Failed : "); +} + +/** + * Call zinc->itemcget ( -color ) + * + * @param item the item to get color from + * @return color value + */ +String Zinc::itemGetColor (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_color; + //call the zinc function with 4 argument in internal form + z_command (4, "itemGetColor Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return String (Tcl_GetStringFromObj (tmp, NULL)); +} + +/** + * Call zinc->itemconfigure ( -connecteditem ) + * + * @param item the item to configure + * @param value the connecteditem to set + */ +void Zinc::itemSetConnecteditem (ZincItem * item, ZincItem * value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_connecteditem; + p1[4] = value->object; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetConnecteditem Failed : "); +} + +/** + * Call zinc->itemcget ( -connecteditem ) + * + * @param item the item to get connecteditem from + * @return connecteditem value + */ +ZincItem * Zinc::itemGetConnecteditem (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_connecteditem; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetConnecteditem Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return new ZincItem(tmp); +} + +/** + * Call zinc->itemconfigure ( -connectionanchor ) + * + * @param item the item to configure + * @param value the connectionanchor to set + */ +void Zinc::itemSetConnectionanchor (ZincItem * item, anchor value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_connectionanchor; + p1[4] = anchors[value]; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetConnectionanchor Failed : "); +} + +/** + * Call zinc->itemcget ( -connectionanchor ) + * + * @param item the item to get connectionanchor from + * @return connectionanchor value + */ +anchor Zinc::itemGetConnectionanchor (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_connectionanchor; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetConnectionanchor Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + anchorsStrings, + "anchors", + 0, &value), + "itemGetConnectionanchor Failed : "); + return (anchor)value; +} + +/** + * Call zinc->itemconfigure ( -image ) + * + * @param item the item to configure + * @param value the image to set + */ +void Zinc::itemSetImage (ZincItem * item, ZincImage * value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_image; + p1[4] = value->object; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetImage Failed : "); +} + +/** + * Call zinc->itemcget ( -image ) + * + * @param item the item to get image from + * @return image value + */ +ZincImage * Zinc::itemGetImage (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_image; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetImage Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return new ZincImage(tmp, true); +} + +/** + * Call zinc->itemconfigure ( -mask ) + * + * @param item the item to configure + * @param value the mask to set + */ +void Zinc::itemSetMask (ZincItem * item, ZincBitmap * value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_mask; + p1[4] = value->object; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetMask Failed : "); +} + +/** + * Call zinc->itemcget ( -mask ) + * + * @param item the item to get mask from + * @return mask value + */ +ZincBitmap * Zinc::itemGetMask (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_mask; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetMask Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return new ZincBitmap (tmp, true); +} + +/** + * Call zinc->itemconfigure ( -alignment ) + * + * @param item the item to configure + * @param value the alignment to set + */ +void Zinc::itemSetAlignment (ZincItem * item, alignment value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_alignment; + p1[4] = alignments[value]; + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetAlignment Failed : "); +} + +/** + * Call zinc->itemcget ( -alignment ) + * + * @param item the item to get alignment from + * @return alignment value + */ +alignment Zinc::itemGetAlignment (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_alignment; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetAlignment Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIndexFromObj (interp, tmp, + alignmentsStrings, + "alignments", + 0, &value), + "itemGetAlignment Failed : "); + return (alignment)value; +} + +/** + * Call zinc->itemconfigure ( -font ) + * + * @param item the item to configure + * @param value the font to set + */ +void Zinc::itemSetFont (ZincItem * item, ZincFont * value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_font; + p1[4] = Z_STR_POOL (0, value->name.c_str(), value->name.length()); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetFont Failed : "); +} + +/** + * Call zinc->itemcget ( -font ) + * + * @param item the item to get font from + * @return font value + */ +ZincFont * Zinc::itemGetFont (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_font; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetFont Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return new ZincFont (Tcl_GetStringResult (interp)); +} + +/** + * Call zinc->itemconfigure ( -overstriked ) + * + * @param item the item to configure + * @param value the overstriked to set + */ +void Zinc::itemSetOverstriked (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_overstriked; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetOverstriked Failed : "); +} + +/** + * Call zinc->itemcget ( -overstriked ) + * + * @param item the item to get overstriked from + * @return overstriked value + */ +bool Zinc::itemGetOverstriked (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_overstriked; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetOverstriked Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetOverstriked Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -spacing ) + * + * @param item the item to configure + * @param value the spacing to set + */ +void Zinc::itemSetSpacing (ZincItem * item, short value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_spacing; + p1[4] = Z_INT_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetSpacing Failed : "); +} + +/** + * Call zinc->itemcget ( -spacing ) + * + * @param item the item to get spacing from + * @return spacing value + */ +short Zinc::itemGetSpacing (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_spacing; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetSpacing Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "itemGetSpacing Failed : "); + return (short)value; +} + +/** + * Call zinc->itemconfigure ( -text ) + * + * @param item the item to configure + * @param value the text to set + */ +void Zinc::itemSetText (ZincItem * item, String value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_text; + p1[4] = Z_STR_POOL (1, value.c_str (), value.length ()); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetText Failed : "); +} + +/** + * Call zinc->itemcget ( -text ) + * + * @param item the item to get text from + * @return text value + */ +String Zinc::itemGetText (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_text; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetText Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + return String (Tcl_GetStringFromObj (tmp, NULL)); +} + +/** + * Call zinc->itemconfigure ( -underlined ) + * + * @param item the item to configure + * @param value the underlined to set + */ +void Zinc::itemSetUnderlined (ZincItem * item, bool value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_underlined; + p1[4] = Z_BOO_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetUnderlined Failed : "); +} + +/** + * Call zinc->itemcget ( -underlined ) + * + * @param item the item to get underlined from + * @return underlined value + */ +bool Zinc::itemGetUnderlined (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_underlined; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetUnderlined Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetBooleanFromObj (interp, tmp, &value), + "itemGetUnderlined Failed : "); + return (bool)value; +} + +/** + * Call zinc->itemconfigure ( -width ) + * + * @param item the item to configure + * @param value the width to set + */ +void Zinc::itemSetWidth (ZincItem * item, unsigned short value) +{ + //prepare arguments : .zinc itemconfigure item attribute value + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_width; + p1[4] = Z_INT_POOL (1, value); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetWidth Failed : "); +} + +/** + * Call zinc->itemcget ( -width ) + * + * @param item the item to get width from + * @return width value + */ +unsigned short Zinc::itemGetWidth (ZincItem * item) +{ + Tcl_Obj* tmp; + //discard all old results + Tcl_ResetResult (interp); + //prepare arguments : .zinc itemcget item + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_width; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetWidth Failed : "); + + //retreive the result trough the tcl interpreter and convert it + tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "itemGetWidth Failed : "); + return (unsigned short)value; +} + + + +/******************************************************* + END OF AUTOGENERATED METHODS +*******************************************************/ + + +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use z_tcl_call which automaticly handle error return + * codes or z_command to call a Zinc command which handle all arguments too. + */ +/** + * Call zinc->itemconfigure ( -firstend ) + * + * @param item the item to get width from + * @param a,b,c values used to set end + */ +void Zinc::itemSetFirstend (ZincItem * item, double a, double b, double c) +{ + String value = dtos (a) + " " + dtos (b) + " " + dtos (c); + // call .zinc itemconfigure item -firstend "a b c" + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_firstend; + p1[4] = Z_STR_POOL (1, value.c_str (), value.length ()); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetFirstend Failed : "); +} + + +/** + * Call zinc->itemcget ( -firstend ) + * + * @param item the item to get width from + * @param a,b,c values used to sedwhere we'll put end + */ +void Zinc::itemGetFirstend (ZincItem * item, double *a, double *b, double *c) +{ + Tcl_Obj *tmp; + int argc; + char * line; + + //discard old results + Tcl_ResetResult (interp); + // call .zinc itemcget item -firstend + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_firstend; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetFirstend Failed : "); + + //get the result as a string + tmp = Tcl_GetObjResult (interp); + line = Tcl_GetStringFromObj (tmp, NULL); + + //interpret the string a 3 double + argc = sscanf(line, "%lf %lf %lf", a, b, c); + if (argc != 3) + { + throw ZincException (String("itemGetFirstend Failed"), __FILE__, __LINE__); + } +} + +/** + * Call zinc->itemconfigure ( -lastend ) + * + * @param item the item to get width from + * @param a,b,c values used to set end + */ +void Zinc::itemSetLastend (ZincItem * item, double a, double b, double c) +{ + String value = dtos (a) + " " + dtos (b) + " " + dtos (c); + // call .zinc itemconfigure item -lastend "a b c" + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_lastend; + p1[4] = Z_STR_POOL (1, value.c_str (), value.length ()); + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetLastend Failed : "); +} + +/** + * Call zinc->itemcget ( -lastend ) + * + * @param item the item to get width from + * @param a,b,c values used to sedwhere we'll put end + */ +void Zinc::itemGetLastend (ZincItem * item, double *a, double *b, double *c) +{ + Tcl_Obj *tmp; + int argc; + char * line; + + //discard old results + Tcl_ResetResult (interp); + // call .zinc itemcget item -lastend + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_lastend; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetLastend Failed : "); + + //get the result as a string + tmp = Tcl_GetObjResult (interp); + line = Tcl_GetStringFromObj (tmp, NULL); + + //interpret the string a 3 double + argc = sscanf(line, "%lf %lf %lf", a, b, c); + if (argc != 3) + { + throw ZincException (String("itemGetLastend Failed"), __FILE__, __LINE__); + } +} + +/** + * Call zinc->itemconfigure ( -position ) + * + * @param item the item to get width fromset position to + * @param x,y position + */ +void Zinc::itemSetPosition (ZincItem * item, double x, double y) +{ + // call .zinc itemconfigure item -position {x y} + p1[0] = id; + p1[1] = ZFCT_itemconfigure; + p1[2] = item->object; + p1[3] = ZOPT_position; + //make a pair + p2[0] = Z_DBL_POOL (1, x); + p2[1] = Z_DBL_POOL (2, y); + p1[4] = Z_LST_POOL (3, p2, 2); // a list of 2 items + //call the zinc function with 5 arguments in internal form + z_command (5, "itemSetPosition Failed : "); + // clean the list No 3 in the pool + Z_CLEANLIST (3); +} + +/** + * Call zinc->itemcget ( -position ) + * + * @param item the item to get position from + * @param x,y position + */ +void Zinc::itemGetPosition (ZincItem * item, double *x, double *y) +{ + Tcl_Obj *tmp; + int num; + Tcl_Obj** elems; + + //discard old results + Tcl_ResetResult (interp); + // call .zinc itemcget item -position + p1[0] = id; + p1[1] = ZFCT_itemcget; + p1[2] = item->object; + p1[3] = ZOPT_position; + //call the zinc function with 4 arguments in internal form + z_command (4, "itemGetPosition Failed : "); + + //retreive the result as a list + tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_ListObjGetElements (interp, tmp, &num, &elems), + "itemGetPosition Failed : "); + + //num is necessarily 2 extract 2 double + z_tcl_call (Tcl_GetDoubleFromObj(interp, elems[0], x), + "itemGetPosition Failed : "); + z_tcl_call (Tcl_GetDoubleFromObj(interp, elems[0], y), + "itemGetPosition Failed : "); +} + +/** + * Create an image object + * + * @param the image reference (a file name) + * @param isPhoto true for a picture, false for an X11 bitmap + */ +ZincImage* Zinc::createImageFromFile (String image) +{ + const char* para[5]; + //discard old results + Tcl_ResetResult (interp); + // prepare arguments to call : image create (photo|bitmap) -file image + para[0] = "image"; + para[1] = "create"; + para[2] = "photo"; + para[3] = "-file"; + para[4] = image.c_str (); + + // call the function with 5 arguments and check for error + z_tcl_call ((*imgCmdInfo.proc)(imgCmdInfo.clientData, interp, 5, para), + "createImageFromFile Failed : "); + return new ZincImage (Tcl_GetObjResult (interp)); +} + +/** + * Create an image object + * + * @param the image reference (a base64 String or binary data) + * @param isPhoto true for a picture, false for an X11 bitmap + */ +ZincImage* Zinc::createImageFromData (String image) +{ + const char* para[5]; + //discard old results + Tcl_ResetResult (interp); + // prepare arguments to call : image create (photo|bitmap) -data image + para[0] = "image"; + para[1] = "create"; + para[2] = "photo"; + para[3] = "-data"; + para[4] = image.c_str (); + + // call the function with 5 arguments and check for error + z_tcl_call ((*imgCmdInfo.proc)(imgCmdInfo.clientData, interp, 5, para), + "createImageFromData Failed : "); + return new ZincImage (Tcl_GetObjResult (interp)); +} + +/** + * Create a bitmap object from a file + * + * @param image the bitmap reference (a file name) + */ +ZincBitmap* Zinc::createBitmapFromFile (String image) +{ + const char* para[5]; + //discard old results + Tcl_ResetResult (interp); + // prepare arguments to call : image create (photo|bitmap) -file image + para[0] = "image"; + para[1] = "create"; + para[2] = "bitmap"; + para[3] = "-file"; + para[4] = image.c_str (); + + // call the function with 5 arguments and check for error + z_tcl_call ((*imgCmdInfo.proc)(imgCmdInfo.clientData, interp, 5, para), + "createBitmapFromFile Failed : "); + return new ZincBitmap (Tcl_GetObjResult (interp), false); +} + +/** + * Create a bitmap object base64 data + * + * @param image the bitmap reference (a base64 String or binary data) + */ +ZincBitmap* Zinc::createBitmapFromData (String image) +{ + const char* para[5]; + //discard old results + Tcl_ResetResult (interp); + // prepare arguments to call : image create (photo|bitmap) -data image + para[0] = "image"; + para[1] = "create"; + para[2] = "bitmap"; + para[3] = "-data"; + para[4] = image.c_str (); + + // call the function with 5 arguments and check for error + z_tcl_call ((*imgCmdInfo.proc)(imgCmdInfo.clientData, interp, 5, para), + "createBitmapFromData Failed : "); + return new ZincBitmap (Tcl_GetObjResult (interp), false); +} + +/** + * Create a bitmap object using a predefined name + * + * @param image the bitmap reference (a name) + */ +ZincBitmap* Zinc::createBitmapFromName (String image) +{ + return new ZincBitmap (image); +} + +/** + * Create an image object + * + * @param width Width of image + * @param height Height of image + * @param aggBuffer An AGG buffer + */ +ZincImage* Zinc::createImageFromAGGBuffer (int width, int height, unsigned char *aggBuffer) +{ + const char* para[7]; + //discard old results + Tcl_ResetResult (interp); + + // create a blank offscreen image + para[0] = "image"; + para[1] = "create"; + para[2] = "photo"; + para[3] = "-height"; + para[4] = String(itos (height).c_str ()).c_str (); + para[5] = "-width"; + para[6] = String(itos (width).c_str ()).c_str (); + + // call the function with 7 arguments and check for error + z_tcl_call ((*imgCmdInfo.proc)(imgCmdInfo.clientData, interp, 7, para), + "createImageFromBuffer Failed : "); + // save result + ZincImage *result = new ZincImage (Tcl_GetObjResult (interp)); + + // get tcl PhotoImage handle + Tk_PhotoHandle photo; + photo = Tk_FindPhoto (interp, Tcl_GetString (result->object)); + if (photo == NULL) + { + // todo: error + } + + // create a PhotoImageBlock + Tk_PhotoImageBlock block; + block.pixelPtr = aggBuffer; + block.width = width; + block.height = height; + block.pitch = block.width * 3; + block.pixelSize = 3; + block.offset[0] = 0; + block.offset[1] = 1; + block.offset[2] = 2; + block.offset[3] = 0; + + /* copy block to photo image and leave the rest to tk */ + Tk_PhotoPutBlock(photo, &block, 0, 0, block.width, block.height, TK_PHOTO_COMPOSITE_SET); + + // return result + return result; +} + + + +/** + * Create a font object + * + * @param family the font mamily + * @param size if a positive number, it is in points, if a negative number, + * its absolute value is a size in pixels. + * @param bold 1 for a bold font, 0 for a normal font, -1 for unspecified + * @param italic 1 an italic font, 0 for a roman font, -1 for unspecified + * @param underline 1 for an underlined, 0 for a normal font, -1 for + * unspecified + * @param overstrike 1 for an overstriked font, 0 for a normal font, -1 for unspecified + */ +ZincFont* Zinc::createFont (String family, int size, int bold, int italic, + int underline, int overstrike) +{ + const char* para[14]; + //quote family to avoid problems with spaces + + //discard old results + Tcl_ResetResult (interp); + // prepare arguments to call : font create -family family -size size + // -weight weight -slant slant -underline underline -overstrike overstrike + para[0] = "font"; + para[1] = "create"; + para[2] = "-family"; + para[3] = family.c_str (); + para[4] = "-size"; + //Warning, weird bug workaround + // here is a deep copy + // without this, on one MDK10.1 machine tcl sees an empty string + String tmp = String(itos (size).c_str ()); + para[5] = tmp.c_str (); + + // use i as a variable parameter pointer + int i=6; // last parameter is para[5] + //handle default value for weight + if (bold != -1) + { + para[i++] = "-weight"; + para[i++] = bold == 1 ? "bold" : "normal"; + } + //handle default value for italic + if (italic != -1) + { + para[i++] = "-slant"; + para[i++] = italic == 1 ? "italic" : "roman"; + } + //handle default value for underline + if (underline != -1) + { + para[i++] = "-underline"; + para[i++] = underline == 1 ? "true" : "false"; + } + //handle default value for overstrike + if (overstrike != -1) + { + para[i++] = "-overstrike"; + para[i++] = overstrike == 1 ? "true" : "false"; + } + + // call the function with i arguments and check for error + z_tcl_call ((*fntCmdInfo.proc)(fntCmdInfo.clientData, interp, i, para), + "createFont Failed : "); + return new ZincFont (Tcl_GetStringResult (interp)); +} + +/** + * Get font ascent + * + * @param font the font + * @return the font ascent + */ +int Zinc::getFontAscent (ZincFont* font) +{ + const char* para[4]; + + //discard old results + Tcl_ResetResult (interp); + // prepare arguments to call : font metrics font -ascent + para[0] = "font"; + para[1] = "metrics"; + para[2] = font->name.c_str(); + para[3] = "-ascent"; + + // call the function with 4 arguments and check for error + z_tcl_call ((*fntCmdInfo.proc)(fntCmdInfo.clientData, interp, 4, para), + "getFontAscent Failed : "); + + //retreive the result as an integer + Tcl_Obj *tmp = Tcl_GetObjResult (interp); + int value; + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "getFontAscent Failed : "); + return value; +} + + +/** + * Get Image width + * + * @param ZincImage the image to get width from + * @return the width of the image + */ +int Zinc::getImageWidth (ZincImage *image) +{ + const char* para[3]; + + //discard old results + Tcl_ResetResult (interp); + // prepare arguments to call : image create (photo|bitmap) -data image + para[0] = "image"; + para[1] = "width"; + para[2] = Tcl_GetString (image->object); + + // call the function with 3 arguments and check for error + z_tcl_call ((*imgCmdInfo.proc)(imgCmdInfo.clientData, interp, 3, para), + "getImageWidth Failed : "); + + int value; + // retreive the result as an integer + Tcl_Obj *tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "getImageWidth Failed : "); + return value; +} + +/** + * Get Image height + * + * @param ZincImage the image to get height from + * @return the height of the image + */ +int Zinc::getImageHeight (ZincImage *image) +{ + const char* para[3]; + + //discard old results + Tcl_ResetResult (interp); + // prepare arguments to call : image create (photo|bitmap) -data image + para[0] = "image"; + para[1] = "height"; + para[2] = Tcl_GetString (image->object); + + // call the function with 3 arguments and check for error + z_tcl_call ((*imgCmdInfo.proc)(imgCmdInfo.clientData, interp, 3, para), + "getImageHeight Failed : "); + + int value; + // retreive the result as an integer + Tcl_Obj *tmp = Tcl_GetObjResult (interp); + z_tcl_call (Tcl_GetIntFromObj (interp, tmp, &value), + "getImageHeight Failed : "); + return value; +} + +/** + * This is inline because it is called frequently and needs to be optimized + * Use this when you need to call a function that can return a TCL error code. + * + * @param fct the full function call + * @param msg the error message to throw in case of error + */ +void Zinc::z_tcl_call (int result, char* p_msg) throw (ZincException) +{ + if (result != TCL_OK) + { + const char *r; + String msg = "zinclib: "; + if (p_msg != NULL) + { + msg.append (p_msg); + } + r = Tcl_GetStringResult (interp); + if (r != NULL) + { + msg.append (r); + } + throw ZincException (msg, __FILE__, __LINE__ ); + } +} + +/** + * This is a inline because it is called frequently and needs to be optimized + * Use this to call the zinObjectCommand fuction. The call is made using the + * pre allocated table p1, it must contain Tcl_Obj thar are parameters to + * the zinObjectCommand function. A parameter indicate how many parameters + * are passed to the zinObjectCommand function. + * + * @param count the number of parameters in p1 + * @param msg the error message to throw in case of error + */ +void Zinc::z_command (int count, char* p_msg) throw (ZincException) +{ + int result = (*objCmd) (wi, interp, (count), p1); + if (result != TCL_OK) + { + const char *r; + String msg = "zinclib: "; + if (p_msg != NULL) + { + msg.append (p_msg); + } + r = Tcl_GetStringResult (interp); + if (r != NULL) + { + msg.append (r); + } + throw ZincException (msg, __FILE__, __LINE__ ); + } +} diff --git a/zinclib.d/src/Zinc.hpp b/zinclib.d/src/Zinc.hpp new file mode 100644 index 0000000..417b697 --- /dev/null +++ b/zinclib.d/src/Zinc.hpp @@ -0,0 +1,1365 @@ +/** Zinc.hpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here is the declaration of the Zinc object + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * David Thevenin <thevenin@intuilab.com> + * + */ +#include "ZincTypes.hpp" +#include "ZincObjects.hpp" +#include "ZincPath.hpp" +#include "ZincExtern.hpp" +#include <tcl.h> + +#ifndef ZINC_HEADER +#define ZINC_HEADER + + +/** Number of objects in the pool */ +const int ZINC_POOL_COUNT = 7; +/** maximum number of parameter in a zinc function */ +const int ZINC_PARAM_COUNT = 10; + +/**Defaults zinc group */ +const int DEFAULT_GROUP = 1; + +/** + * This class contains a zinc widget and members to create and modify items + */ +class Zinc +{ + friend class ZincPath; + +public: + Tcl_Obj *id; ///< the id of this object + WidgetObjCmd objCmd; ///< the command associated with this object + ClientData wi; ///< the zinc object itself + String tclCb; ///< name of the binding callback + int znId; ///< the znCount at creation time + String window; ///< the window which contains the widget + + static int znCount; ///< count to create unique ids + static Tcl_CmdInfo topCmdInfo; ///< the command associated with toplevel + static Tcl_CmdInfo zncCmdInfo; ///< the command associated with zinc + static Tcl_CmdInfo imgCmdInfo; ///< the command associated with image + static Tcl_CmdInfo fntCmdInfo; ///< the command associated with font + static Tcl_CmdInfo focCmdInfo; ///< the command associated with fous + static Tcl_CmdInfo bndCmdInfo; ///< the command associated with bind + static Tcl_Obj* pool[ZINC_POOL_COUNT];///< a pool of tclobj ready to be used + static Tcl_Obj* p1[ZINC_PARAM_COUNT]; ///< table of pointeur use for parameters + static Tcl_Obj* p2[ZINC_PARAM_COUNT]; ///< table of pointeur use for parameters + +public: + static Tcl_Interp *interp; ///< the tcl interpreter + + /** + * The public constructor + * + * @param renderingMode ZINC_BACKEND_X11 or ZINC_BACKEND_OPENGL + */ + Zinc (int renderingMode); + + /** + * The public destructor + */ + ~Zinc (); + + /** + * Change window title + * + * @param title the title string + */ + void setTitle (String title); + +/***************************************** + WIDGET PROPERTIES +*****************************************/ + + /** + * Call zinc->configure ( -backcolor ) + * + * @param value the backcolor to set + */ + void setBackcolor (String value); + + /** + * Call zinc->cget ( -backcolor ) + * + * @return backcolor value + */ + String getBackcolor (); + + /** + * Call zinc->configure ( -forecolor ) + * + * @param value the forecolor to set + */ + void setForecolor (String value); + + /** + * Call zinc->cget ( -forecolor ) + * + * @return forecolor value + */ + String getForecolor (); + + /** + * Call zinc->configure ( -width ) + * + * @param value the width to set + */ + void setWidth (int value); + + /** + * Call zinc->cget ( -width ) + * + * @return width value + */ + int getWidth (); + + /** + * Call zinc->configure ( -height ) + * + * @param value the height to set + */ + void setHeight (int value); + + /** + * Call zinc->cget ( -height ) + * + * @return height value + */ + int getHeight (); + + /** + * Call zinc->configure ( -borderwidth ) + * + * @param value the borderwidth to set + */ + void setBorderwidth (int value); + + /** + * Call zinc->cget ( -borderwidth ) + * + * @return borderwidth value + */ + int getBorderwidth (); + + /** + * Call zinc->configure ( -font ) + * + * @param value the font to set + */ + void setFont (ZincFont* value); + + /** + * Call zinc->cget ( -font ) + * + * @return font value + */ + ZincFont* getFont (); + +/***************************************** + WIDGET METHODS +*****************************************/ + + /** + * Get the bounding box of an item + * + * @param item the item to get bbox + * @param bbox a table where we'll put the bounding box + * bbox[0] = x0, bbox[1] = y0, bbox[2] = xc, bbox[3] = yc + */ + void bbox (ZincItem* item, double bbox[4]); + + /** + * Get the bounding box of an item in its parent group + * + * @param item the item to get bbox in its parent group + * @param bbox a table where we'll put the bounding box + * bbox[0] = x0, bbox[1] = y0, bbox[2] = xc, bbox[3] = yc + */ + void relativeBbox (ZincItem* item, double bbox[4]); + + + /** + * Change the group of an item + * + * @param item the item to move + * @param parentGroup new group for the item + */ + void chggroup (ZincItem *item, ZincItem *parentGroup); + + /** + * Clone an item + * + * @param item the item to clone + * @return the cloned item + */ + ZincItem* clone (ZincItem *item); + + /** + * Get the number of contour of an item + * + * @return number of contour + */ + int contour (ZincItem *item); + + /** + * Set the contour of an item to the one of an other + * + * @param item the item on which we set the contour + * @param flag the operation to do on the contour + * @param reference the item to set contour from + * @return the number of contour + */ + int contour (ZincItem *item, itemOperator flag, ZincItem *reference); + + /** + * Set the contour of an item + * + * @param item the item on which we set the contour + * @param add true to add a path, false to remove + * @param reference the new contour + * @return the number of contour + */ + int contour (ZincItem *item, bool add, ZincPath *contour); + + /** + * Set or modify the coordinates of an item + * + * @param item the item to modify + * @param contour new coords for the item + * @param add true to add coords, false to replace + * @param contourIndex the contour do modify + * @param coordIndex the coordinate to modify (WARNING, path must be one + * point if the is not the default) + */ + void coords (ZincItem *item, ZincPath *contour, bool add, + int contourIndex = -1, int coordIndex = -1); + + /** + * Remove coords of an item + * + * @param item the item to modify + * @param coordIndex the coordinate to rmove + * @param contourIndex the contour on which we remove + */ + void coordsRemove (ZincItem *item, int coordIndex, int contourIndex = -1); + + /** + * Add a tag to an item + * + * @param item the item to add tag to + * @param tag a tag to add + */ + void addTag (ZincItem *item, String tag); + + /** + * Remove a tag from an item + * + * @param item the item to remove tag from + * @param tag a tag to remove (nothing to remove all tags) + */ + void dTag (ZincItem *item, String tag = String("")); + + /** + * List all tags of an item + * It's up to the caller to delete the resulting table and strings + * + * @param item the item to list tag from + * @param lagList a pointer to a table of String containing tags + * @return the number of tags + */ + int getTags (ZincItem *item, String*** tagList); + + /** + * Set the focus to an item + * + * @param item the item to set the focus to + */ + void focus (ZincItem *item); + + /** + * Tell if the name is a gradient name + * + * @param gname a gradient name + * @return true if the name is a gradient name, false otherwise + */ + bool isGname (String gname); + + /** + * Create a named gradient + * + * @param gradient a gradient + * @param gname a gradient name + */ + void gname (String gradient, String gname); + + /** + * Retreive the group of an item + * + * @param item the item to get the group from + * @return the group + */ + ZincItem* group (ZincItem *item); + + /** + * Reorder items to lower one + * + * @param item the item to lower + */ + void lower (ZincItem *item); + + /** + * Reorder items to lower one + * + * @param item the item to lower + * @param belowThis and item that will be over item + */ + void lower (ZincItem *item, ZincItem *belowThis); + + /** + * Reorder items to raise one + * + * @param item the item to raise + */ + void raise (ZincItem *item); + + /** + * Reorder items to raise one + * + * @param item the item to raise + * @param aboveThis an item that will be under item + */ + void raise (ZincItem *item, ZincItem *aboveThis); + + /** + * Return the type of an item + * + * @param item an item + * @return the type of the item + */ + itemType type (ZincItem *item); + + /** + * Create a Zinc Tag that can be used in place of any item + * for zinc functions that must be called using tagOrId + * + * @param tag the text of the tag + * @return a tag item + */ + ZincItem* createTag(String tag); + +/***************************************** + ITEMS MANIPULATION +*****************************************/ + /** + * Suppress an item + * + * @param item the item to suppress + */ + void itemRemove (ZincItem *item); + + /** + * Create a group item + * + * @param parentGroup group where we'll put the new group, if NULL we create + * in the defaults group + * @return the group item + */ + ZincItem *itemCreateGroup (ZincItem *parentGroup); + + /** + * Create a rectangle item + * + * @param parentGroup group where we'll put it + * @param x y width height the coordinates of the new rectangle + * @return the rectangle item + */ + ZincItem *itemCreateRectangle (ZincItem *parentGroup, double x, double y, + double width, double height); + + /** + * Create an arc item + * + * @param parentGroup group where we'll put it + * @param x y width height the coordinates of the new rectangle + * @return the arc item + */ + ZincItem *itemCreateArc (ZincItem *parentGroup, double x, double y, + double width, double height); + + /** + * Create a text item + * + * @param parentGroup group where we'll put it + * @return the text item + */ + ZincItem *itemCreateText (ZincItem *parentGroup); + + /** + * Create a curve item + * + * @param parentGroup group where we'll put it + * @param path the path to display + * @return the curve item + */ + ZincItem *itemCreateCurve (ZincItem *parentGroup, ZincPath *path); + + /** + * Create an icon item + * + * @param parentGroup group where we'll put it + * @param image a zincImage to display + * @return the icon item + */ + ZincItem *itemCreateIcon (ZincItem *parentGroup, ZincImage* image); + + +/************************************************** + BINDING +**************************************************/ + + /** + * Bind a function to an event on the zinc widget + * + * @param eventSpecification tcl style event specicication + * @param callBack the function which will be called back + * @param userData data we will give back to the callback when called + * @param add false to replace existing bind or true to add + */ + void bind (String eventSpecification, + ZincWidgetCallback callBack, void *userData, bool add = false); + + /** + * Annulate a binding + * + * @param eventSpecification tcl style event specicication + */ + void unbind (String eventSpecification); + + /** + * Bind a function to an event on an item + * + * @param item the item on which to bind + * @param eventSpecification tcl style event specicication + * @param callBack the function which will be called back + * @param userData data we will give back to the callback when called + * @param add false to replace existing bind or true to add + */ + void itemBind (ZincItem *item, String eventSpecification, + ZincItemCallback callBack, void *userData, bool add = false); + + /** + * Annulate a binding + * + * @param item the item on which to unbind + * @param eventSpecification tcl style event specicication + */ + void itemUnbind (ZincItem *item, String eventSpecification); + +/************************************************** + TRANSFORMATION METHODS +**************************************************/ + + /** + * Translate the item + * + * @param item the item to which we apply the transform + * @param dx dy translation vector + */ + void itemTranslate (ZincItem * item, double dx, double dy); + + /** + * Translate the item + * + * @param item the item to which we apply the transform + * @param x y translation vector + * @param absolute true if the translation is absolute + */ + void itemTranslate (ZincItem * item, double x, double y, bool absolute); + + /** + * Rotate an item + * + * @param item the item to which we apply the transform + * @param angle the angle to rotate in radian + */ + void itemRotate (ZincItem * item, double angle); + + /** + * Rotate an item + * + * @param item the item to which we apply the transform + * @param angle the angle to rotate in radian + * @param x y the center of the rotation + */ + void itemRotate (ZincItem * item, double angle, double x, double y); + + /** + * Rotate an item + * + * @param item the item to which we apply the transform + * @param angle the angle to rotate + * @param degree true for an angle in degree, false for an angle in radians + */ + void itemRotate (ZincItem * item, double angle, bool degree); + + /** + * Rotate an item + * + * @param item the item to which we apply the transform + * @param angle the angle to rotate in radian + * @param x y the center of the rotation + * @param degree true for an angle in degree, false for an angle in radians + */ + void itemRotate (ZincItem * item, double angle, double x, double y, + bool degree); + + /** + * Scale an item + * + * @param item the item to which we apply the transform + * @param ax horizontal scale + * @param ay vertical scale + */ + void itemScale (ZincItem * item, double ax, double ay); + + /** + * Scale an item using a specified center + * + * @param item the item to which we apply the transform + * @param ax horizontal scale + * @param ay vertical scale + * @param cx cy center of the scale + */ + void itemScale (ZincItem * item, double ax, double ay, double cx, double cy); + + + /** + * Skew an item + * + * @param item the item to which we apply the transform + * @param sx horizontal skew + * @param sy vertical skew + */ + void itemSkew (ZincItem * item, double sx, double sy); + + /** + * Skew an item horizontaly + * + * @param item the item to which we apply the transform + * @param sx horizontal skew + */ + void itemSkewX (ZincItem * item, double sx); + + /** + * Skew an item verticaly + * + * @param item the item to which we apply the transform + * @param sy vertical skew + */ + void itemSkewY (ZincItem * item, double sy); + + /** + * Reset all transformations associated with the item + * + * @param item the item to which we apply the transform + */ + void itemResetTransformation (ZincItem * item); + + /** + * Replace current transform by a matrix + * + * @param item the item to which we apply the transform + * @param a,b,c,d,e,f the new transform matrix + */ + void itemSetTransformation (ZincItem * item, + double a, double b, double c, + double d, double e, double f); + + /** + * Get current transform matrix + * + * @param item the item to which we apply the transform + * @param a,b,c,d,e,f places where we'll put the transform matrix + */ + void itemGetTransformation (ZincItem * item, + double *a, double *b, double *c, + double *d, double *e, double *f); + + /** + * Multiply current transform by a matrix + * + * @param item the item to which we apply the transform + * @param a,b,c,d,e,f the new transform matrix + */ + void itemMatrix (ZincItem * item, + double a, double b, double c, + double d, double e, double f); + +/******************************************************* + AUTOGENERATED METHODS (itemconfigure) +"code.hpp" in Tkzins/generic source from : + ./gen.pl Arc.c Attrs.c Color.c Curve.c Draw.c Group.c + Image.c List.c Item.c Icon.c Rectangle.c tkZinc.c Text.c +*******************************************************/ + + /** + * Call zinc->itemconfigure ( -closed ) + * @param item the item to configure + * @param value the closed to set + */ + void itemSetClosed (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -closed ) + * @param item the item to get closed from + * @return closed value + */ + bool itemGetClosed (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -composealpha ) + * @param item the item to configure + * @param value the composealpha to set + */ + void itemSetComposealpha (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -composealpha ) + * @param item the item to get composealpha from + * @return composealpha value + */ + bool itemGetComposealpha (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -composerotation ) + * @param item the item to configure + * @param value the composerotation to set + */ + void itemSetComposerotation (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -composerotation ) + * @param item the item to get composerotation from + * @return composerotation value + */ + bool itemGetComposerotation (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -composescale ) + * @param item the item to configure + * @param value the composescale to set + */ + void itemSetComposescale (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -composescale ) + * @param item the item to get composescale from + * @return composescale value + */ + bool itemGetComposescale (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -extent ) + * @param item the item to configure + * @param value the extent to set + */ + void itemSetExtent (ZincItem * item, unsigned int value); + + /** + * Call zinc->itemcget ( -extent ) + * @param item the item to get extent from + * @return extent value + */ + unsigned int itemGetExtent (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -fillcolor ) + * @param item the item to configure + * @param value the fillcolor to set + */ + void itemSetFillcolor (ZincItem * item, String value); + + /** + * Call zinc->itemcget ( -fillcolor ) + * @param item the item to get fillcolor from + * @return fillcolor value + */ + String itemGetFillcolor (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -filled ) + * @param item the item to configure + * @param value the filled to set + */ + void itemSetFilled (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -filled ) + * @param item the item to get filled from + * @return filled value + */ + bool itemGetFilled (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -fillpattern ) + * @param item the item to configure + * @param value the fillpattern to set + */ + void itemSetFillpattern (ZincItem * item, ZincBitmap * value); + + /** + * Call zinc->itemcget ( -fillpattern ) + * @param item the item to get fillpattern from + * @return fillpattern value + */ + ZincBitmap * itemGetFillpattern (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -linecolor ) + * @param item the item to configure + * @param value the linecolor to set + */ + void itemSetLinecolor (ZincItem * item, String value); + + /** + * Call zinc->itemcget ( -linecolor ) + * @param item the item to get linecolor from + * @return linecolor value + */ + String itemGetLinecolor (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -linepattern ) + * @param item the item to configure + * @param value the linepattern to set + */ + void itemSetLinepattern (ZincItem * item, ZincBitmap * value); + + /** + * Call zinc->itemcget ( -linepattern ) + * @param item the item to get linepattern from + * @return linepattern value + */ + ZincBitmap * itemGetLinepattern (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -linestyle ) + * @param item the item to configure + * @param value the linestyle to set + */ + void itemSetLinestyle (ZincItem * item, lineStyle value); + + /** + * Call zinc->itemcget ( -linestyle ) + * @param item the item to get linestyle from + * @return linestyle value + */ + lineStyle itemGetLinestyle (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -linewidth ) + * @param item the item to configure + * @param value the linewidth to set + */ + void itemSetLinewidth (ZincItem * item, double value); + + /** + * Call zinc->itemcget ( -linewidth ) + * @param item the item to get linewidth from + * @return linewidth value + */ + double itemGetLinewidth (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -pieslice ) + * @param item the item to configure + * @param value the pieslice to set + */ + void itemSetPieslice (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -pieslice ) + * @param item the item to get pieslice from + * @return pieslice value + */ + bool itemGetPieslice (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -priority ) + * @param item the item to configure + * @param value the priority to set + */ + void itemSetPriority (ZincItem * item, unsigned int value); + + /** + * Call zinc->itemcget ( -priority ) + * @param item the item to get priority from + * @return priority value + */ + unsigned int itemGetPriority (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -sensitive ) + * @param item the item to configure + * @param value the sensitive to set + */ + void itemSetSensitive (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -sensitive ) + * @param item the item to get sensitive from + * @return sensitive value + */ + bool itemGetSensitive (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -startangle ) + * @param item the item to configure + * @param value the startangle to set + */ + void itemSetStartangle (ZincItem * item, unsigned int value); + + /** + * Call zinc->itemcget ( -startangle ) + * @param item the item to get startangle from + * @return startangle value + */ + unsigned int itemGetStartangle (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -tile ) + * @param item the item to configure + * @param value the tile to set + */ + void itemSetTile (ZincItem * item, ZincBitmap * value); + + /** + * Call zinc->itemcget ( -tile ) + * @param item the item to get tile from + * @return tile value + */ + ZincBitmap * itemGetTile (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -visible ) + * @param item the item to configure + * @param value the visible to set + */ + void itemSetVisible (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -visible ) + * @param item the item to get visible from + * @return visible value + */ + bool itemGetVisible (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -capstyle ) + * @param item the item to configure + * @param value the capstyle to set + */ + void itemSetCapstyle (ZincItem * item, capStyle value); + + /** + * Call zinc->itemcget ( -capstyle ) + * @param item the item to get capstyle from + * @return capstyle value + */ + capStyle itemGetCapstyle (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -fillrule ) + * @param item the item to configure + * @param value the fillrule to set + */ + void itemSetFillrule (ZincItem * item, fillRule value); + + /** + * Call zinc->itemcget ( -fillrule ) + * @param item the item to get fillrule from + * @return fillrule value + */ + fillRule itemGetFillrule (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -joinstyle ) + * @param item the item to configure + * @param value the joinstyle to set + */ + void itemSetJoinstyle (ZincItem * item, joinStyle value); + + /** + * Call zinc->itemcget ( -joinstyle ) + * @param item the item to get joinstyle from + * @return joinstyle value + */ + joinStyle itemGetJoinstyle (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -relief ) + * @param item the item to configure + * @param value the relief to set + */ + void itemSetRelief (ZincItem * item, relief value); + + /** + * Call zinc->itemcget ( -relief ) + * @param item the item to get relief from + * @return relief value + */ + relief itemGetRelief (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -smoothrelief ) + * @param item the item to configure + * @param value the smoothrelief to set + */ + void itemSetSmoothrelief (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -smoothrelief ) + * @param item the item to get smoothrelief from + * @return smoothrelief value + */ + bool itemGetSmoothrelief (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -alpha ) + * @param item the item to configure + * @param value the alpha to set + */ + void itemSetAlpha (ZincItem * item, unsigned int value); + + /** + * Call zinc->itemcget ( -alpha ) + * @param item the item to get alpha from + * @return alpha value + */ + unsigned int itemGetAlpha (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -atomic ) + * @param item the item to configure + * @param value the atomic to set + */ + void itemSetAtomic (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -atomic ) + * @param item the item to get atomic from + * @return atomic value + */ + bool itemGetAtomic (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -clip ) + * @param item the item to configure + * @param value the clip to set + */ + void itemSetClip (ZincItem * item, ZincItem * value); + + /** + * Call zinc->itemcget ( -clip ) + * @param item the item to get clip from + * @return clip value + */ + ZincItem * itemGetClip (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -anchor ) + * @param item the item to configure + * @param value the anchor to set + */ + void itemSetAnchor (ZincItem * item, anchor value); + + /** + * Call zinc->itemcget ( -anchor ) + * @param item the item to get anchor from + * @return anchor value + */ + anchor itemGetAnchor (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -color ) + * @param item the item to configure + * @param value the color to set + */ + void itemSetColor (ZincItem * item, String value); + + /** + * Call zinc->itemcget ( -color ) + * @param item the item to get color from + * @return color value + */ + String itemGetColor (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -connecteditem ) + * @param item the item to configure + * @param value the connecteditem to set + */ + void itemSetConnecteditem (ZincItem * item, ZincItem * value); + + /** + * Call zinc->itemcget ( -connecteditem ) + * @param item the item to get connecteditem from + * @return connecteditem value + */ + ZincItem * itemGetConnecteditem (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -connectionanchor ) + * @param item the item to configure + * @param value the connectionanchor to set + */ + void itemSetConnectionanchor (ZincItem * item, anchor value); + + /** + * Call zinc->itemcget ( -connectionanchor ) + * @param item the item to get connectionanchor from + * @return connectionanchor value + */ + anchor itemGetConnectionanchor (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -image ) + * @param item the item to configure + * @param value the image to set + */ + void itemSetImage (ZincItem * item, ZincImage * value); + + /** + * Call zinc->itemcget ( -image ) + * @param item the item to get image from + * @return image value + */ + ZincImage * itemGetImage (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -mask ) + * @param item the item to configure + * @param value the mask to set + */ + void itemSetMask (ZincItem * item, ZincBitmap * value); + + /** + * Call zinc->itemcget ( -mask ) + * @param item the item to get mask from + * @return mask value + */ + ZincBitmap * itemGetMask (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -alignment ) + * @param item the item to configure + * @param value the alignment to set + */ + void itemSetAlignment (ZincItem * item, alignment value); + + /** + * Call zinc->itemcget ( -alignment ) + * @param item the item to get alignment from + * @return alignment value + */ + alignment itemGetAlignment (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -font ) + * @param item the item to configure + * @param value the font to set + */ + void itemSetFont (ZincItem * item, ZincFont * value); + + /** + * Call zinc->itemcget ( -font ) + * @param item the item to get font from + * @return font value + */ + ZincFont * itemGetFont (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -overstriked ) + * @param item the item to configure + * @param value the overstriked to set + */ + void itemSetOverstriked (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -overstriked ) + * @param item the item to get overstriked from + * @return overstriked value + */ + bool itemGetOverstriked (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -spacing ) + * @param item the item to configure + * @param value the spacing to set + */ + void itemSetSpacing (ZincItem * item, short value); + + /** + * Call zinc->itemcget ( -spacing ) + * @param item the item to get spacing from + * @return spacing value + */ + short itemGetSpacing (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -text ) + * @param item the item to configure + * @param value the text to set + */ + void itemSetText (ZincItem * item, String value); + + /** + * Call zinc->itemcget ( -text ) + * @param item the item to get text from + * @return text value + */ + String itemGetText (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -underlined ) + * @param item the item to configure + * @param value the underlined to set + */ + void itemSetUnderlined (ZincItem * item, bool value); + + /** + * Call zinc->itemcget ( -underlined ) + * @param item the item to get underlined from + * @return underlined value + */ + bool itemGetUnderlined (ZincItem * item); + + /** + * Call zinc->itemconfigure ( -width ) + * @param item the item to configure + * @param value the width to set + */ + void itemSetWidth (ZincItem * item, unsigned short value); + + /** + * Call zinc->itemcget ( -width ) + * @param item the item to get width from + * @return width value + */ + unsigned short itemGetWidth (ZincItem * item); + + +/******************************************************* + END OF AUTOGENERATED METHODS +*******************************************************/ + + /** + * Call zinc->itemconfigure ( -firstend ) + * + * @param item the item to set firstend to + * @param a,b,c values used to set end + */ + void itemSetFirstend (ZincItem * item, double a, double b, double c); + + /** + * Call zinc->itemcget ( -firstend ) + * + * @param item the item to get firstend from + * @param a,b,c values used to sedwhere we'll put end + */ + void itemGetFirstend (ZincItem * item, double *a, double *b, double *c); + + /** + * Call zinc->itemconfigure ( -lastend ) + * + * @param item the item to set lastend to + * @param a,b,c values used to set end + */ + void itemSetLastend (ZincItem * item, double a, double b, double c); + + /** + * Call zinc->itemcget ( -lastend ) + * + * @param item the item to get lastend from + * @param a,b,c values used to sedwhere we'll put end + */ + void itemGetLastend (ZincItem * item, double *a, double *b, double *c); + + /** + * Call zinc->itemconfigure ( -position ) + * + * @param item the item to get width fromset position to + * @param x,y position + */ + void itemSetPosition (ZincItem * item, double x, double y); + + /** + * Call zinc->itemcget ( -position ) + * + * @param item the item to get position from + * @param x,y position + */ + void itemGetPosition (ZincItem * item, double *x, double *y); + + /** + * Create an image object from a file + * + * @param image the image reference (a file name) + */ + ZincImage* createImageFromFile (String image); + + /** + * Create an image object using base64 data + * + * @param image the image reference (a base64 String or binary data) + */ + ZincImage* createImageFromData (String image); + + /** + * Create a bitmap object from a file + * + * @param image the bitmap reference (a file name) + */ + ZincBitmap* createBitmapFromFile (String image); + + /** + * Create a bitmap object base64 data + * + * @param image the bitmap reference (a base64 String or binary data) + */ + ZincBitmap* createBitmapFromData (String image); + + /** + * Create a bitmap object using a predefined name + * + * @param image the bitmap reference (a name) + */ + ZincBitmap* createBitmapFromName (String image); + + /** + * Create an image object + * + * @param width Width of image + * @param height Height of image + * @param aggBuffer An AGG buffer + */ + ZincImage* createImageFromAGGBuffer (int width, int height, unsigned char *aggBuffer); + + + /** + * Create a font object + * + * @param family the font mamily + * @param size if a positive number, it is in points, if a negative number, + * its absolute value is a size in pixels. + * @param bold 1 for a bold font, 0 for a normal font, -1 for unspecified + * @param italic 1 an italic font, 0 for a roman font, -1 for unspecified + * @param underline 1 for an underlined, 0 for a normal font, -1 for + * unspecified + * @param overstrike 1 for an overstriked font, 0 for a normal font, -1 for unspecified + */ + ZincFont* createFont (String family, int size, int bold = -1, + int italic = -1, int underline = -1, + int overstrike = -1); + + /** + * Get font ascent + * + * @param font the font + * @return the font ascent + */ + int getFontAscent (ZincFont* font); + + /** + * Get Image width + * + * @param ZincImage the image to get width from + * @return the width of the image + */ + int getImageWidth (ZincImage *image); + + /** + * Get Image height + * + * @param ZincImage the image to get height from + * @return the height of the image + */ + int getImageHeight (ZincImage *image); + +/******************************************************* + STATIC PROCEDURES +*******************************************************/ + + /** + * Loads the zinc library and initialize tcl and tk + * + * @param argv0 the name of the execytable as passed in argv[0] + */ + static void loadZinc (char *argv0) throw (ZincException); + + /** + * Run tk mainloop and returns when there is no more Tk window + */ + static void zincMainLoop (); + +/******************************************************* + errors management +*******************************************************/ + /** + * This is inline because it is called frequently and needs to be optimized + * Use this when you need to call a function that can return a TCL error code. + * + * @param fct the full function call + * @param msg the error message to throw in case of error + */ + static void z_tcl_call (int result, char* p_msg) throw (ZincException); + + /** + * This is a inline because it is called frequently and needs to be optimized + * Use this to call the zinObjectCommand fuction. The call is made using the + * pre allocated table p1, it must contain Tcl_Obj thar are parameters to + * the zinObjectCommand function. A parameter indicate how many parameters + * are passed to the zinObjectCommand function. + * + * @param count the number of parameters in p1 + * @param msg the error message to throw in case of error + */ + void z_command (int count, char* p_msg) throw (ZincException); + +}; + +#endif diff --git a/zinclib.d/src/ZincExtern.hpp b/zinclib.d/src/ZincExtern.hpp new file mode 100644 index 0000000..193a684 --- /dev/null +++ b/zinclib.d/src/ZincExtern.hpp @@ -0,0 +1,74 @@ +/** ZincExtern.hpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here we create TkZinc library headers since they don't exist + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * + */ +#include <tcl.h> + +#ifndef ZINC_EXTERN +#define ZINC_EXTERN + + +// those are function have been created within a C compiler +extern "C" +{ + + //The TkZinc function that initialises tkzinc + int Tkzinc_Init(Tcl_Interp *interp); + + //The TkZinc function that creates a zinc object + int ZincObjCmd(ClientData client_data, // Main window associated with interpreter. + Tcl_Interp *interp, // Current interpreter. + int argc, // Number of arguments. + Tcl_Obj *CONST args[]); // Argument objects. + + //The TkZinc function that is called by tcl when calling ".zinc fct ..." +#ifdef _WIN32 + typedef int (__cdecl *WidgetObjCmd) + (ClientData client_data, // Information about the widget. + Tcl_Interp *interp, // Current interpreter. + int argc, // Number of arguments. + Tcl_Obj *CONST args[]); // Argument objects. +#else + typedef int (*WidgetObjCmd) + (ClientData client_data, // Information about the widget. + Tcl_Interp *interp, // Current interpreter. + int argc, // Number of arguments. + Tcl_Obj *CONST args[]) // Argument objects. + __attribute__((cdecl)); +#endif +} + +#endif + diff --git a/zinclib.d/src/ZincInternal.hpp b/zinclib.d/src/ZincInternal.hpp new file mode 100644 index 0000000..63feaf2 --- /dev/null +++ b/zinclib.d/src/ZincInternal.hpp @@ -0,0 +1,182 @@ +/** ZincInternal.hpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here we defines macros and constants that are only used within Zinclib code + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * David Thevenin <thevenin@intuilab.com> + * + */ + +#include <string> +#include <stdio.h> +#ifdef _WIN32 +#define snprintf _snprintf +#endif + +#include "ZincObjects.hpp" +#ifndef BAZAR +#define BAZAR + +#define MAX_NUM_LENGTH 32 + +// The base name of the TCL function that serve for callbacks +#define Z_TCLCB "zincTclCb" + +/** + * These are macro for shortness and readability of code. + * They take one Tcl_Obj from the pool and put one value into it. This object + * is returned. They all have the same signature. + * + * @param no the id of the Tcl_Obj to take within the pool (max is + * ZINC_POOL_COUNT-1) + * @param value the value to put in the extracted object + * @return the object from the pool + */ +// make a boolean object +#define Z_BOO_POOL(no, value) ( Tcl_SetBooleanObj (pool[no], value), pool[no] ) +// make an integer object +#define Z_INT_POOL(no, value) ( Tcl_SetIntObj (pool[no], value), pool[no] ) +// make a double object +#define Z_DBL_POOL(no, value) ( Tcl_SetDoubleObj (pool[no], value), pool[no] ) +// make a string object +#define Z_STR_POOL(no, value, length) ( Tcl_SetStringObj (pool[no], \ + value, length), \ + pool[no] ) + +/** + * Make a list object + * + * @param no the id of the Tcl_Obj to take within the pool + * @param value a table of pointer to Tcl_Obj to put in the list + * @param size the number objects in the table + * @return the list object from the pool + */ +#define Z_LST_POOL(no, value, size) ( Tcl_SetListObj (pool[no], size, value),\ + pool[no] ) + +/** + * Clear a list object. Tcl_Obj used in a list object have a refcount + * incremented and as such can't be reused for anything else. To free those + * object you need to clean the list object after use. + * + * @param no the id of a Tcl_Obj within the pool which contains a list to + * clear + */ +#define Z_CLEANLIST(no) Tcl_SetIntObj (pool[no], 0) + + +/** + * Create a constant Tcl_Obj that can be reused as a parameter later + * + * @parameter string define the name and the value ov the object + */ +//create an option object (value prefixed by '-') +#define Z_DEFINE_ZOPT(string) Tcl_Obj* ZOPT_##string = Tcl_NewStringObj ("-" #string, -1); +//create a function object +#define Z_DEFINE_ZFCT(string) Tcl_Obj* ZFCT_##string = Tcl_NewStringObj (#string, -1); +//create an item object +#define Z_DEFINE_ZITM(string) Tcl_Obj* ZITM_##string = Tcl_NewStringObj (#string, -1); + +/** + * Macro to return a parentGroup Tcl_Obj. If a NULL is group given, it returns + * the default one. + * + * @param parentGroup the parent group to take + */ +#define Z_PARENTGROUP(parentGroup) \ + ( (parentGroup != NULL) ? parentGroup->object : DEFAULT_GROUP_OBJ ); + +/** + * Convert an integer to a string + * + * @param integer the integer to convert + */ +inline std::string itos (int integer) +{ + char tmp[MAX_NUM_LENGTH]; + // use standard function to convert + if (snprintf (tmp, MAX_NUM_LENGTH, "%d", integer) < 0) + { + throw ZincException ("Error converting integer", __FILE__, __LINE__ ); + } + return std::string (tmp); +} + +/** + * Convert a long to a string + * + * @param l the long to convert + */ +inline std::string ltos (long l) +{ + char tmp[MAX_NUM_LENGTH]; + // use standard function to convert + if (snprintf (tmp, MAX_NUM_LENGTH, "%ld", l) < 0) + { + throw ZincException ("Error converting long", __FILE__, __LINE__ ); + } + return std::string (tmp); +} + +/** + * Convert a double to a string + * + * @param double the integer to convert + */ +inline std::string dtos (double d) +{ + char tmp[MAX_NUM_LENGTH]; + // use standard function to convert + if (snprintf (tmp, MAX_NUM_LENGTH, "%f", d) < 0) + { + throw ZincException ("Error converting double", __FILE__, __LINE__ ); + } + return std::string (tmp); +} + +/** + * How To call Zinc or Tcl functions: + * + * All arguments of the function are Tcl_Obj. To accelerate their call, there + * is a pool of preconstructed Tcl_Obj and some often used constant Tcl_Obj. + * p1 and p2 are tables of pointers to be used for arguments. + * Fill p1 using either predefined objects like ZITM_* or a pool objet that + * you can fill with the value you want. + * Ex : p1[1] = ZFCT_add; + * Macros have been defined to fill and use a pool object + * Ex : p1[2] = Z_INT_POOL(1, 200); + * Do not use twice the same pool index for the same function call. + * p2 is used to construct and argument which is a list of Tcl_Obj. + * To call the function use Z_TCL_CALL which automaticly handle error return + * codes or Z_COMMAND to call a Zinc command which handle all arguments too. + */ +#endif diff --git a/zinclib.d/src/ZincObjects.cpp b/zinclib.d/src/ZincObjects.cpp new file mode 100644 index 0000000..3a0ad2d --- /dev/null +++ b/zinclib.d/src/ZincObjects.cpp @@ -0,0 +1,201 @@ +/** ZincObjects.cpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here we defines classes that are items in zinc + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * David Thevenin <thevenin@intuilab.com> + * + */ +#include "ZincInternal.hpp" +#include "ZincObjects.hpp" +#include "Zinc.hpp" + + +/** + * The protected default constructor + */ +ZincItem::ZincItem () +{ } + +/** + * The public constructor + * + * @param obj the object we want to store + */ +ZincItem::ZincItem (Tcl_Obj *obj) + : object(obj) +{ + // manage refcount so that the tcl_obj can't be freed + Tcl_IncrRefCount (object); +} + +/** + * The public destructor + */ +ZincItem::~ZincItem () +{ + // dercrement refcount to free tcl_obj + Tcl_DecrRefCount (object); +} + +/** + * The public constructor + * + * @param obj the object we want to store + */ +ZincImage::ZincImage (Tcl_Obj *obj) + : ZincItem (obj), madeFromInternal (false) +{ } + +/** + * The public constructor + * + * @param obj the object we want to store + */ +ZincImage::ZincImage (Tcl_Obj *obj, bool internal) + : ZincItem (obj), madeFromInternal (internal) +{ } + +/** + * The public destructor + */ +ZincImage::~ZincImage () +{ + // do not delete returned values + if (madeFromInternal) + return; + + // delete using string commands + const char* para[5]; + para[0] = "image"; + para[1] = "delete"; + para[2] = Tcl_GetString(object); + + // call the function with 3 arguments + int res = (*Zinc::imgCmdInfo.proc)(Zinc::imgCmdInfo.clientData, + Zinc::interp, 3, para); + Zinc::z_tcl_call (res, "delete ZincImage Failed : "); +} + +/** + * The public constructor (redefine the inherited one) + * + * @param obj the object we want to store + */ +ZincBitmap::ZincBitmap (Tcl_Obj *obj) + : ZincItem (obj), madeFromInternal (false) +{ } + +/** + * The public constructor (redefine the inherited one) + * + * @param obj the object we want to store + */ +ZincBitmap::ZincBitmap (Tcl_Obj *obj, bool internal) + : ZincItem (obj), madeFromInternal (internal) +{ } + +/** + * The public constructor (redefine the inherited one) + * + * @param name the name of a predefined bitmap + */ +ZincBitmap::ZincBitmap (String name) + : madeFromInternal (true) +{ + object = Tcl_NewStringObj (name.c_str(), name.length ()); + Tcl_IncrRefCount (object); +} + +/** + * The public destructor + */ +ZincBitmap::~ZincBitmap () +{ + // do not delete Zinc default bitmaps or returned values + if (madeFromInternal) + return; + + // delete using string commands + const char* para[5]; + para[0] = "image"; + para[1] = "delete"; + para[2] = Tcl_GetString(object); + + // call the function with 3 arguments + int res = (*Zinc::imgCmdInfo.proc)(Zinc::imgCmdInfo.clientData, + Zinc::interp, 3, para); + Zinc::z_tcl_call (res, "delete ZincBitmap Failed : "); +} + +/** + * The public constructor + */ +ZincFont::ZincFont (const char *font) + : name (String (font)) +{ } + +/** + * A public constructor with a String parameter + * + * @param msg the error message + */ +ZincException::ZincException (String p_msg, char *p_file, int p_lineNo) + : msg (p_msg), file(p_file), line(p_lineNo) +{ } + +/** + * Copy constructor + * + * @param exception the original exception + */ +ZincException::ZincException (const ZincException &e) + : msg (e.msg), file(e.file), line(e.line) +{ } + +/** + * Public destructor + */ +ZincException::~ZincException () throw() +{ } + +/** + * Retreive the exception message + * + * @return the message + */ +const char* ZincException::what () const throw () +{ + String result = "Zinc Exception : "; + result += msg + " file " + file + ", line " + itos (line); + return result.c_str (); +} diff --git a/zinclib.d/src/ZincObjects.hpp b/zinclib.d/src/ZincObjects.hpp new file mode 100644 index 0000000..dc46567 --- /dev/null +++ b/zinclib.d/src/ZincObjects.hpp @@ -0,0 +1,198 @@ +/** ZincObjects.hpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here we defines classes that are items in zinc + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * David Thevenin <thevenin@intuilab.com> + * + */ +#include "ZincTypes.hpp" + +#include <exception> +#include <string> +#include <tcl.h> + +#ifndef ZINC_OBJECTS +#define ZINC_OBJECTS + +// Object representing a zinc item +class ZincItem +{ +protected: + /** + * The protected default constructor + */ + ZincItem (); + +public: + Tcl_Obj *object; //the object we are storing + + /** + * The public constructor + * + * @param obj the object we want to store + */ + ZincItem (Tcl_Obj *obj); + + /** + * The public destructor + */ + virtual ~ZincItem (); +}; + +// Object representing a zinc image +class ZincImage : public ZincItem +{ + /** + * The private constructor + */ + ZincImage (); + + bool madeFromInternal; + +public: + /** + * The public constructor (redefine the inherited one) + * + * @param obj the object we want to store + */ + ZincImage (Tcl_Obj *obj); + + /** + * The public constructor (redefine the inherited one) + * + * @param obj the object we want to store + */ + ZincImage (Tcl_Obj *obj, bool internal); + + /** + * The public destructor + */ + virtual ~ZincImage (); +}; + +// Object representing a zinc bitmap +class ZincBitmap : public ZincItem +{ + /** + * The private constructor + */ + ZincBitmap (); + + bool madeFromInternal; + +public: + /** + * The public constructor (redefine the inherited one) + * + * @param obj the object we want to store + */ + ZincBitmap (Tcl_Obj *obj); + + /** + * The public constructor (redefine the inherited one) + * + * @param obj the object we want to store + */ + ZincBitmap (Tcl_Obj *obj, bool internal); + + /** + * The public constructor (redefine the inherited one) + * + * @param name the name of a predefined bitmap + */ + ZincBitmap (String name); + + /** + * The public destructor + */ + virtual ~ZincBitmap (); +}; + +// Object representing a zinc font +class ZincFont +{ + /** + * The public default constructor + */ + ZincFont (); + +public: + String name; + + /** + * The public constructor + */ + ZincFont (const char *font); + +}; + +/** + * Exceptions that are throwed by zinclib + */ +class ZincException : public std::exception +{ + +private: + String msg; // the exception message + String file; // file where exception have been caught + int line; // line where exception have been caught + +public: + /** + * A public constructor with a String parameter + * + * @param msg the error message + */ + ZincException (String msg, char *file, int lineNo); + + /** + * Copy constructor + * + * @param exception the original exception + */ + ZincException (const ZincException &exception); + + /** + * Public destructor + */ + virtual ~ZincException () throw(); + + /** + * Retreive the exception message + * + * @return the message + */ + const char* what () const throw (); +}; + +#endif diff --git a/zinclib.d/src/ZincPath.cpp b/zinclib.d/src/ZincPath.cpp new file mode 100644 index 0000000..a120014 --- /dev/null +++ b/zinclib.d/src/ZincPath.cpp @@ -0,0 +1,415 @@ +/** Path.cpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here we defines The ZincPath object + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * + */ +#include "Zinc.hpp" +#include "ZincInternal.hpp" + +#include <math.h> + +// convert degree to radians +const double convertRatio = atan2 (1., 1.) * 4. / 180.; + +/** + * Calculate d % m for doubles + * this is because the C % works only for integers + */ +inline double modulo (double d, double m) +{ + return d - (floor (d / m) * m); +// return d; +} + +/** + * Append the point to the real path + * + * @param x,y the point coordinate + * @param c true if the point is a control point + */ +inline void ZincPath::addPoint (double x, double y, bool c) +{ + // update last control point + lastX = x; + lastY = y; + + // we can't use a flat list since zinc accepts flat list only for simple + // lines + Tcl_Obj* point[3]; + int i = 2; + //create a point object + //an object for x + point[0] = Tcl_NewDoubleObj (x); + // an object for y + point[1] = Tcl_NewDoubleObj (y); + // an object for 'c' only if needed + if (c) + { + point[2] = Tcl_NewStringObj ("c", -1); + i = 3; + } + + // the point (this increments refcount) + Tcl_Obj* tmp = Tcl_NewListObj (i, point); + // append the point to the list + Zinc::z_tcl_call ( Tcl_ListObjAppendElement (Zinc::interp, path, tmp), + "addpoint Error:"); +} + +/** + * Convert ellipse from SVG form to centered form (used only by arcTo) + * + * @param x0,y0 origin of the arc + * @param rx x-radius of ellipse in degree (can be modified) + * @param ry y-radius of ellipse in degree (can be modified) + * @param phi rotation of ellipse in degree (can be modified) + * @param largeArc true if the large part of the ellipse + * @param sweep true for a positive angle direction for the drawing + * @param x,y destination point + * @param cx,cy center coordinate + * @param theta begining of arc in degree + * @param delta extent of arc in degree + */ +void ZincPath::convertFromSvg (double x0, double y0, double &rx, double &ry, + double &phi, bool largeArc, bool sweep, + double x, double y, double &cx, double &cy, + double &theta, double &delta) +{ + /* all this strictly follow the script given in "SVG essentials" + * p85 : convert an elliptical arc fo SVG to an elliptical arc + * based around a central point + */ + + // temporary variables + double dx2, dy2, phiR, x1, y1; + double rxSq, rySq, x1Sq, y1Sq; + double sign, sq, coef, radiusCheck; + double cx1, cy1, sx2, sy2; + double p, n, ux, uy, vx, vy; + + // compute 1/2 distance between current and final point + dx2 = (x0 - x) / 2.; + dy2 = (y0 - y) / 2.; + + //convert from degree to radians + phi = modulo (phi, 360.); + phiR = phi * convertRatio; + + //compute (x1, y1) + x1 = cos (phiR) * dx2 + sin (phiR) * dy2; + y1 = -sin (phiR) * dx2 + cos (phiR) * dy2; + + // make sure radii are large enough + rx = fabs (rx); ry = fabs (ry); + rxSq = rx * rx; + rySq = ry * ry; + x1Sq = x1 * x1; + y1Sq = y1 * y1; + + radiusCheck = (x1Sq / rxSq) + (y1Sq / rySq); + if (radiusCheck > 1.) + { + rx *= sqrt (radiusCheck); + ry *= sqrt (radiusCheck); + rxSq = rx * rx; + rySq = ry * ry; + } + + //step 2 compute (cx1, cy1) + sign = (largeArc == sweep) ? -1. : 1.; + sq = ((rxSq * rySq) - (rxSq * y1Sq) - (rySq * x1Sq)) / + ((rxSq * y1Sq) + (rySq * x1Sq)); + sq = (sq < 0.) ? 0. : sq; + coef = (sign * sqrt (sq)); + cx1 = coef * ((rx * y1) / ry); + cy1 = coef * -((ry * x1) / rx); + + //step 3 : compute (cx, cy) from (cx1, cy1) + sx2 = (x0 + x) / 2; + sy2 = (y0 + y) / 2; + + cx = sx2 + (cos (phiR) * cx1 - sin (phiR) * cy1); + cy = sy2 + (sin (phiR) * cx1 + cos (phiR) * cy1); + + //step 4 : compute angle start angle extent + ux = (x1 - cx1) / rx; + uy = (y1 - cy1) / ry; + vx = (-x1 - cx1) / rx; + vy = (-y1 - cy1) / ry; + n = sqrt ((ux *ux) + (uy * uy)); + p = ux; // 1 * ux + 0 * uy + sign = (uy < 0.) ? -1. : 1.; + + theta = sign * acos (p /n); + theta = theta / convertRatio; + + n = sqrt ((ux * ux + uy * uy) * (vx * vx + vy * vy)); + p = ux * vx + uy * vy; + sign = ((ux * vy - uy * vx) < 0.) ? -1. : 1.; + delta = sign * acos (p / n); + delta = delta / convertRatio;; + + if (!sweep && delta > 0.) + { + delta -= 360.; + } + else if (sweep && delta < 0.) + { + delta += 360.; + } + +// delta = modulo (delta, 360.); +// theta = modulo (theta, 360.); +} + + +/** + * The public constructor + * + * @param x,y the initial point + */ +ZincPath::ZincPath (double x, double y) + : firstX (x), firstY (y) +{ + // create a default path + path = Tcl_NewListObj (0, NULL); + // the path must not be deleted by tcl + Tcl_IncrRefCount (path); + // add the first point + addPoint (x, y, false); +} + +/** + * The public destructor + * + * @warning Do not destroy a ZincPath if Zinc is not loaded + */ +ZincPath::~ZincPath () +{ + //decrement reference count on all objs in list -> free + Tcl_SetIntObj (path, 1); + //decrement reference count on the list -> free + Tcl_DecrRefCount (path); +} + +/** + * Close current path + */ +void ZincPath::close () +{ + addPoint (firstX, firstY, false); +} + +/** + * Draw a line from current point to next point + * + * @param x,y next point + */ +void ZincPath::lineTo (double x, double y) +{ + addPoint (x, y, false); +} + +/** + * Draw a cubic bezier using specified control and destination points + * call cubicBezierTo + * + * @param cx1,cy1 first control point + * @param cx2,cy2 second control point + * @param x,y destination point + */ +void ZincPath::curveTo (double cx1, double cy1, double cx2, double cy2, + double x, double y) +{ + cubicBezierTo (cx1, cy1, cx2, cy2, x, y); +} + +/** + * Draw a cubic bezier using specified control and destination points + * + * @param cx1,cy1 first control point + * @param cx2,cy2 second control point + * @param x,y destination point + */ +void ZincPath::cubicBezierTo (double cx1, double cy1, + double cx2, double cy2, + double x, double y) +{ + addPoint (cx1, cy1, true); + addPoint (cx2, cy2, true); + addPoint (x, y, false); +} + +/** + * Draw a quadratic bezier using specified control and destination point + * + * @param cx1,cy1 first control point + * @param cx2,cy2 second control point + * @param x,y destination point + */ +void ZincPath::quadraticBezierTo (double cx, double cy, double x, double y) +{ + // convert from a quadratic bezier to a cubic bezier + // since that's what is supported by zinc + /* [[x1, y1], [qx, qy, 'q'], [x2,y2]] + cx1 = x1 + (qx - x1) * 2/3 + cy1 = y1 + (qy - y1) * 2/3 + cx2 = qx + (x2 - qx)/3 + cy2 = qy + (y2 - qy)/3 + */ + double cx1 = lastX + (cx - lastX) * 2/3; + double cy1 = lastY + (cy - lastY) * 2/3; + double cx2 = cx + (x - cx) / 3; + double cy2 = cy + (y - cy) / 3; + addPoint (cx1, cy1, true); + addPoint (cx2, cy2, true); + addPoint (x, y, false); +} + +/** + * Draw an arc from current point to x,y + * + * @param rx x-radius of ellipse + * @param ry y-radius of ellipse + * @param xAxisRotation rotation of ellipse + * @param largeArc true if the large part of the ellipse + * @param sweepFlag true for a positive angle direction for the drawing + * @param x,y destination point + */ +void ZincPath::arcTo (double rx, double ry, double xAxisRotation, bool largeArc, + bool sweepFlag, double x, double y) +{ + double sx, sy, start, arc; + // convert to a centered representation + convertFromSvg (lastX, lastY, rx, ry, xAxisRotation, largeArc, sweepFlag, + x, y, sx, sy, start, arc); + + // this is all taken from first case study for Intuikit + + /* convert to a curve representation + * For a good approximation, we need 8 quadratic Bezier + * to make a circle : the maximal angle is 45° + */ + // local variables + int segs; + double segAngle, angle, angleMid; + double cosphi, sinphi, tx, ty; + double previousX, previousY; + double bx, by, qx, qy; + double cx1, cy1, cx2, cy2; + + //1) calculate segment counts + segs = int (ceil (fabs (arc) / 45.)); + + //let's create segments of the same angle + //2) calculate this angle + segAngle = arc / double(segs) * convertRatio; + + xAxisRotation = xAxisRotation * convertRatio; + start = start * convertRatio; + + //3) Our fake starting point (relative to (x,y)) + // true start point is (x,y) + sx = lastX - cos (start) * rx; + sy = lastY - sin (start) * ry; + + /* 4) calculate values that will be used for a rotation + * of centre (x,y) and angle phi + * the matrix is : + * cos(phi) -sin(phi) tx + * sin(phi) cos(phi) ty + * 0 0 1 + */ + cosphi = cos (xAxisRotation); + sinphi = sin (xAxisRotation); + tx = (1. - cosphi) * lastX + sinphi * lastY; + ty = (1. - cosphi) * lastY - sinphi * lastX; + + //5) save crrent values + previousX = lastX; + previousY = lastY; + angle = start; + + //6) we already got the first point + + //7) calculate segments + for (int i(0) ; i < segs ; i++) + { + //7.1) increment angle + angle += segAngle; + + //7.2) calculate intermediate angle value + angleMid = angle - segAngle / 2.; + + //7.3) calculate last point of the segment from center and rays + bx = sx + cos (angle) * rx; + by = sy + sin (angle) * ry; + + //7.4) calculate control point for the quadratic bezier curve + qx = sx + cos (angleMid) * (rx / cos (segAngle / 2.)); + qy = sy + sin (angleMid) * (ry / cos (segAngle / 2.)); + + //7.5) calculate control points for the equivalent bezier curve + cx1 = previousX + (qx - previousX) * 2. / 3.; + cy1 = previousY + (qy - previousY) * 2. / 3.; + cx2 = qx + (bx - qx) / 3.; + cy2 = qy + (by - qy) / 3.; + + //7.6) add points + addPoint (cosphi * cx1 - sinphi * cy1 + tx, + sinphi * cx1 + cosphi * cy1 + ty, true); + addPoint (cosphi * cx2 - sinphi * cy2 + tx, + sinphi * cx2 + cosphi * cy2 + ty, true); + addPoint (cosphi * bx - sinphi * by + tx, + sinphi * bx + cosphi * by + ty, false); + + //7.7) Save last point + previousX = bx; + previousY = by; + } + +} + +/** + * Return a table of Tcl_Obj* containing a liste of coords points + * It's up to the caller to delete the resulting table + * + * @return a Tcl_Obj* of type list + */ +Tcl_Obj* ZincPath::getTable () +{ + return path; +} + + diff --git a/zinclib.d/src/ZincPath.hpp b/zinclib.d/src/ZincPath.hpp new file mode 100644 index 0000000..4b6fa21 --- /dev/null +++ b/zinclib.d/src/ZincPath.hpp @@ -0,0 +1,162 @@ +/** Path.hpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here we defines The ZincPath object + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * + */ +#include "ZincTypes.hpp" + +#include <list> +#include <tcl.h> + +#ifndef ZINC_PATH +#define ZINC_PATH + +class ZincPath +{ + double firstX, firstY; //first point's coordinate + double lastX, lastY; //last point's coordinate + Tcl_Obj* path; //list of points + + /** + * Append the point to the real path + * + * @param x,y the point coordinate + * @param c true if the point is a control point + */ + inline void addPoint (double x, double y, bool c); + + /** + * Convert ellipse from SVG form to centered form (used only by arcTo) + * + * @param x0,y0 origin of the arc + * @param rx x-radius of ellipse in degree (can be modified) + * @param ry y-radius of ellipse in degree (can be modified) + * @param phi rotation of ellipse in degree (can be modified) + * @param largeArc true if the large part of the ellipse + * @param sweep true for a positive angle direction for the drawing + * @param x,y destination point + * @param cx,cy center coordinate + * @param theta begining of arc in degree + * @param delta extent of arc in degree + */ + void convertFromSvg (double x0, double y0, double &rx, double &ry, double &phi, + bool larcgeArc, bool sweep, double x, double y, + double &cx, double &cy, double &theta, double &delta); + + +public: + /** + * The public constructor + * + * @param x,y the initial point + */ + ZincPath (double x, double y); + + /** + * The public destructor + * + * @warning Do not destroy a ZincPath if Zinc is not loaded + */ + ~ZincPath (); + + /****************************************** + ZincPath manipulation + ******************************************/ + /** + * Close current path + */ + void close (); + + /** + * Draw a line from current point to next point + * + * @param x,y next point + */ + void lineTo (double x, double y); + + /** + * Draw a cubic bezier using specified control and destination points + * call cubicBezierTo + * + * @param cx1,cy1 first control point + * @param cx2,cy2 second control point + * @param x,y destination point + */ + void curveTo (double cx1, double cy1, double cx2, double cy2, + double x, double y); + + /** + * Draw a cubic bezier using specified control and destination points + * + * @param cx1,cy1 first control point + * @param cx2,cy2 second control point + * @param x,y destination point + */ + void cubicBezierTo (double cx1, double cy1, double cx2, double cy2, + double x, double y); + + /** + * Draw a quadratic bezier using specified control and destination point + * + * @param cx1,cy1 first control point + * @param cx2,cy2 second control point + * @param x,y destination point + */ + void quadraticBezierTo (double cx, double cy, double x, double y); + + /** + * Draw an arc from current point to x,y + * + * @param rx x-radius of ellipse + * @param ry y-radius of ellipse + * @param xAxisRotation rotation of ellipse + * @param largeArc true if the large part of the ellipse + * @param sweepFlag true for a positive angle direction for the drawing + * @param x,y destination point + */ + void arcTo (double rx, double ry, double xAxisRotation, bool largeArc, + bool sweepFlag, double x, double y); + + /** + * Return a Tcl_Obj* containing a list of coords points + * It's up to the caller to delete the resulting table + * + * @return a Tcl_Obj* of type list + */ + Tcl_Obj* getTable (); + +}; + +#endif + diff --git a/zinclib.d/src/ZincTypes.hpp b/zinclib.d/src/ZincTypes.hpp new file mode 100644 index 0000000..236ef1f --- /dev/null +++ b/zinclib.d/src/ZincTypes.hpp @@ -0,0 +1,188 @@ +/** ZincTypes.hpp + * zinclib + * + * This software is the property of IntuiLab SA, France. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Here we defines types and constants that may be usefull for a zinclib user + * + * 08/03/05 + * + * Contributors: + * Benoit Peccatte <peccatte@intuilab.com> + * + */ +#include <string> + +#ifndef ZINC_TYPES +#define ZINC_TYPES + +typedef std::string String; + +/********************************** + Predeclaration of Zinc types +**********************************/ +class Zinc; +class ZincPath; +class ZincItem; +class ZincImage; +class ZincFont; +struct ZincEvent; + +/******************************************************* + Signature to use when binding with a callback +*******************************************************/ +typedef void (*ZincItemCallback) + (Zinc *zinc, // Information about the widget. + ZincItem *item, // the item being evented + ZincEvent *event, // event information + void *userData); // user data provided with bind + +typedef void (*ZincWidgetCallback) + (Zinc *zinc, // Information about the widget. + ZincEvent *event, // event information + void *userData); // user data provided with bind + + +/*********************************** + Library constants +***********************************/ + +// Rendering model +const int ZINC_BACKEND_X11 = 0; +const int ZINC_BACKEND_OPENGL = 1; + + +/*********************************** + Library enums +***********************************/ + +//Styles for line items +typedef enum +{ + lineStyle_simple = 0, + lineStyle_dashed, + lineStyle_mixed, + lineStyle_dotted +} lineStyle; + +//Styles for line cap +typedef enum +{ + capStyle_butt = 0, + capStyle_projecting, + capStyle_round +} capStyle; + +//List of fill rules +typedef enum +{ + fillRule_odd = 0 , + fillRule_nonzero, + fillRule_positive, + fillRule_negative, + fillRule_abs_geq_2 +} fillRule; + +//list of join style +typedef enum +{ + joinStyle_bevel = 0, + joinStyle_miter, + joinStyle_round +} joinStyle; + +//list of reliefs +typedef enum +{ + relief_flat = 0, + relief_raised, + relief_sunken, + relief_ridge, + relief_groove, + relief_roundraised, + relief_roundsunken, + relief_roundridge, + relief_roundgroove, + relief_raisedrule, + relief_sunkenrule +} relief; + +//List of alignments +typedef enum +{ + alignment_left = 0, + alignment_right, + alignment_center +} alignment; + +//list of anchors +typedef enum +{ + anchor_nw = 0, + anchor_n, + anchor_ne, + anchor_e, + anchor_se, + anchor_s, + anchor_sw, + anchor_w, + anchor_center +} anchor; + +//actions to take when calling contour +typedef enum +{ + item_add_clockwise, + item_add_counterclockwise, + item_remove +} itemOperator; + +//list of possible itemtypes +typedef enum +{ + item_group, + item_arc, + item_text, + item_rectangle, + item_curve, + item_icon +} itemType; + +//informations contained in an event +struct ZincEvent +{ + int x,y; // pointer position none -> 0 + int k; // keycode none -> 0 + long t; // timestamp none -> 0 + int w,h; // window width,heigth none -> 0 + int X,Y; // pointer position within display none -> 0 + int b; // button pressed none -> 0 + String K; // keysym none -> "??" +}; + + + +#endif |