diff options
Diffstat (limited to 'zinclib.d/src/Zinc.cpp')
| -rw-r--r-- | zinclib.d/src/Zinc.cpp | 4540 |
1 files changed, 4540 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__ ); + } +} |