Step #3: replace sciPointObj pointers by UIDs in setters. 66/4266/3
Bruno JOFRET [Tue, 21 Jun 2011 14:06:31 +0000 (16:06 +0200)]
Change-Id: I31fb0d1b990711110969a6448caac45287cde0a4

163 files changed:
scilab/modules/graphics/includes/BuildObjects.h
scilab/modules/graphics/includes/SetProperty.h
scilab/modules/graphics/sci_gateway/c/sci_set.c
scilab/modules/graphics/src/c/BuildObjects.c
scilab/modules/graphics/src/c/GetCommandArg.c
scilab/modules/graphics/src/c/InitObjects.c
scilab/modules/graphics/src/c/SetProperty.c
scilab/modules/graphics/src/c/getHandleProperty/SetHashTable.c
scilab/modules/graphics/src/c/getHandleProperty/SetHashTable.h
scilab/modules/graphics/src/c/getHandleProperty/get_current_figure_property.c
scilab/modules/graphics/src/c/getHandleProperty/setGetHashTable.h
scilab/modules/graphics/src/c/getHandleProperty/setHandleProperty.h
scilab/modules/graphics/src/c/getHandleProperty/set_alignment_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_anti_aliasing_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_arc_drawing_method_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_arrow_size_factor_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_arrow_size_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_auto_clear_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_auto_dimensionning_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_auto_position_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_auto_resize_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_auto_rotation_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_auto_scale_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_auto_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_axes_bounds_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_axes_reverse_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_axes_size_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_axes_visible_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_background_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_bar_layout_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_bar_width_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_box_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_callback_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_callback_type_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_callbackmevent_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_cdata_mapping_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_children_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_clip_box_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_clip_state_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_closed_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_color_flag_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_color_map_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_color_mode_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_color_range_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_colored_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_cube_scaling_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_current_axes_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_current_entity_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_current_figure_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_data_bounds_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_data_mapping_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_data_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_data_property.h
scilab/modules/graphics/src/c/getHandleProperty/set_default_values_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_dimension_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_event_handler_enable_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_event_handler_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_figure_id_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_figure_name_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_figure_position_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_figure_size_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_figure_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_fill_mode_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_filled_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_font_angle_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_font_color_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_font_foreground_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_font_size_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_font_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_foreground_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_format_n_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_fractional_font_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_grid_position_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_grid_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_handle_visible_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_hidden_axis_color_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_hidden_color_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_immediate_drawing_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_info_message_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_interp_color_mode_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_interp_color_vector_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_isoview_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_label_font_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_labels_font_color_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_labels_font_size_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_legend_location_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_line_mode_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_line_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_links_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_log_flags_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_margins_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_mark_background_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_mark_foreground_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_mark_mode_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_mark_size_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_mark_size_unit_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_mark_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_old_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_outside_colors_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_parent_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_pixel_drawing_mode_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_pixmap_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_polyline_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_position_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_rotation_angles_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_rotation_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_screen_position_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_segs_color_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_sub_tics_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_surface_color_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_surface_mode_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_tag_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_text_box_mode_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_text_box_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_text_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_thickness_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_tics_color_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_tics_direction_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_tics_labels_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_tics_segment_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_tics_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_tight_limits_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_title_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_triangles_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_user_data_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_view_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_viewport_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_visible_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_x_label_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_x_location_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_x_shift_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_x_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_xtics_coord_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_y_label_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_y_location_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_y_shift_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_y_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_yticks_coord_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_z_bounds_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_z_label_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_z_shift_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_z_ticks_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_zoom_box_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_zoom_state_property.c
scilab/modules/graphics/src/c/sciCall.c
scilab/modules/graphics/src/nographics/nographics.c
scilab/modules/gui/includes/GetUicontrolBackgroundColor.h
scilab/modules/gui/includes/GetUiobjectForegroundColor.h
scilab/modules/gui/includes/SetUicontrolBackgroundColor.h
scilab/modules/gui/includes/SetUicontrolString.h
scilab/modules/gui/includes/SetUimenuLabel.h
scilab/modules/gui/includes/SetUiobjectCallback.h
scilab/modules/gui/includes/SetUiobjectForegroundColor.h
scilab/modules/gui/src/cpp/GetUicontrolBackgroundColor.cpp
scilab/modules/gui/src/cpp/GetUiobjectForegroundColor.cpp
scilab/modules/gui/src/cpp/SetUicontrolBackgroundColor.cpp
scilab/modules/gui/src/cpp/SetUicontrolString.cpp
scilab/modules/gui/src/cpp/SetUimenuLabel.cpp
scilab/modules/gui/src/cpp/SetUiobjectForegroundColor.cpp
scilab/modules/renderer/src/cpp/labelDrawing/LabelPositioner.cpp
scilab/modules/renderer/src/cpp/legendDrawing/ConcreteDrawableLegend.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/Camera.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/ConcreteDrawableSubwin.cpp

index 26d42ec..7aa4e02 100644 (file)
@@ -4,20 +4,20 @@
  * Copyright (C) 2002 - 2004 - INRIA - Djalel Abdemouche
  * Copyright (C) 2004 - 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
 
 /*------------------------------------------------------------------------
- *    Graphic library 
+ *    Graphic library
  *    newGraph Library header
  *    Comment:
- *    This file contains all functions used to BUILD new objects : 
+ *    This file contains all functions used to BUILD new objects :
       - allocating memory
       - setting default value
       - binding the newly created object tyo the entire existing hierarchy
@@ -43,59 +43,54 @@ GRAPHICS_IMPEXP sciPointObj * allocateText( sciPointObj        * pparentsubwin,
                                    double              userSize[2]   ,
                                    BOOL                centerPos     ,
                                    int               * foreground    ,
-                                   int               * background    , 
+                                   int               * background    ,
                                    BOOL                isboxed       ,
                                    BOOL                isline        ,
                                    BOOL                isfilled      ,
                                    sciTextAlignment    align          ) ;
 
 GRAPHICS_IMPEXP sciPointObj * ConstructText (sciPointObj * pparentsubwin, char ** text, int nbRow, int nbCol, double x,
-                                    double y, BOOL autoSize, double userSize[2], BOOL centerPos, int *foreground, int *background, 
+                                    double y, BOOL autoSize, double userSize[2], BOOL centerPos, int *foreground, int *background,
                                     BOOL isboxed, BOOL isline, BOOL isfilled, sciTextAlignment align ) ;
-    
+
 
 GRAPHICS_IMPEXP sciPointObj *ConstructLegend (sciPointObj * pparentfigure, char *text[], long long tabofhandles[],
                                     int nblegends);  /* BUILD */
 
-GRAPHICS_IMPEXP sciPointObj * allocatePolyline(sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pvecz,
-                               int closed, int n1,int plot, int *foreground, int *background,
-                               int *mark_style, int *mark_foreground, int *mark_background,
-                               BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded);
-                               
-GRAPHICS_IMPEXP sciPointObj *ConstructPolyline (sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pvecz,
+GRAPHICS_IMPEXP char *ConstructPolyline (char* pparentsubwinUID, double *pvecx, double *pvecy, double *pvecz,
                                       int closed, int n1, int plot, int *foreground, int *background,
                                       int *mark_style, int *mark_foreground, int *mark_background,
                                       BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded); /* BUILD */
-                                      
+
 GRAPHICS_IMPEXP sciPointObj *ConstructArc (sciPointObj * pparentsubwin, double x, double y,
-                                 double height, double width, double alphabegin, double alphaend, 
+                                 double height, double width, double alphabegin, double alphaend,
                                  int *foreground, int *background, BOOL isfilled, BOOL isline);
 
 GRAPHICS_IMPEXP sciPointObj *ConstructRectangle (sciPointObj * pparentsubwin, double x, double y,
                                        double height, double width,  int *foreground, int *background,
                                        int isfilled, int isline);
 
-GRAPHICS_IMPEXP sciPointObj *ConstructSurface (sciPointObj * pparentsubwin, sciTypeOf3D typeof3d, 
+GRAPHICS_IMPEXP sciPointObj *ConstructSurface (sciPointObj * pparentsubwin, sciTypeOf3D typeof3d,
                                      double * pvecx, double * pvecy, double * pvecz,
-                                     double *zcol, int izcol, int dimzx, int dimzy, 
+                                     double *zcol, int izcol, int dimzx, int dimzy,
                                      int *flag, double *ebox, int flagcolor, int *isfac,
-                                     int *m1, int *n1, int *m2, int *n2, 
+                                     int *m1, int *n1, int *m2, int *n2,
                                      int *m3, int *n3, int *m3n, int *n3n); /* BUILD */
 
 
-GRAPHICS_IMPEXP sciPointObj *ConstructGrayplot (sciPointObj * pparentfigure,double *vx,double *vy, 
+GRAPHICS_IMPEXP sciPointObj *ConstructGrayplot (sciPointObj * pparentfigure,double *vx,double *vy,
                                    double *vz,int nx,int ny, int type); /* BUILD */
 
 GRAPHICS_IMPEXP sciPointObj *ConstructAxes (sciPointObj * pparentsubwin, char dir, char tics, double *vx,
-                                   int nx, double *vy, int ny, char *str[], int subint, char *format, 
+                                   int nx, double *vy, int ny, char *str[], int subint, char *format,
                                    int fontsize, int textcolor, int ticscolor, char logscale, int seg, int nb_tics_labels);  /* BUILD */
 
-GRAPHICS_IMPEXP sciPointObj *ConstructFec (sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pnoeud, 
-                                 double *pfun, int Nnode, int Ntr, double *zminmax, 
+GRAPHICS_IMPEXP sciPointObj *ConstructFec (sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pnoeud,
+                                 double *pfun, int Nnode, int Ntr, double *zminmax,
                                  int *colminmax, int *colout, BOOL with_mesh); /* BUILD */
 
-GRAPHICS_IMPEXP sciPointObj *ConstructSegs (sciPointObj * pparentsubwin, int type,double *vx, double *vy, double *vz, int Nbr1, 
-               int Nbr2, int Nbr3, double *vfx, double *vfy, int flag, 
+GRAPHICS_IMPEXP sciPointObj *ConstructSegs (sciPointObj * pparentsubwin, int type,double *vx, double *vy, double *vz, int Nbr1,
+               int Nbr2, int Nbr3, double *vfx, double *vfy, int flag,
               int *style, double arsize,  int colored, int typeofchamp);  /* BUILD */
 
 GRAPHICS_IMPEXP sciPointObj *ConstructCompound (long *tabpointobj, int number); /* BUILD */
index 5114586..b296039 100644 (file)
@@ -5,17 +5,18 @@
  * Copyright (C) 2004 - 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2005 - INRIA - Jean-Baptiste Silvy
  * Copyright (C) 2010 - Paul Griffiths
- * 
+ * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
 
 /*------------------------------------------------------------------------
- *    Graphic library 
+ *    Graphic library
  *    -This file contains all functions used to SET the properties of graphics
  *    objects.
  *    - there are two kinds of functions : the sciInit*** which only set an object
 #include "ObjectStructure.h"
 #include "BOOL.h"
 
-GRAPHICS_IMPEXP void Obj_RedrawNewAngle(sciPointObj * pSubwin, double alpha, double theta); /* SET  */
+GRAPHICS_IMPEXP void Obj_RedrawNewAngle(char* pSubwin, double alpha, double theta); /* SET  */
 
-GRAPHICS_IMPEXP int sciSetEntityType (sciPointObj * pobj, sciEntityType value); /* SET */
-GRAPHICS_IMPEXP int sciSetColormap (sciPointObj * pobj, double *rgbmat,
+GRAPHICS_IMPEXP int sciSetEntityType (char* pobj, sciEntityType value); /* SET */
+GRAPHICS_IMPEXP int sciSetColormap (char* pobj, double *rgbmat,
                           int m, int n); /* SET */
-GRAPHICS_IMPEXP int sciInitNumColors( sciPointObj * pobj, int numcolors ) ; /* SET */
-GRAPHICS_IMPEXP int sciSetNumColors ( sciPointObj * pobj, int numcolors ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitNumColors( char* pobj, int numcolors ) ; /* SET */
+GRAPHICS_IMPEXP int sciSetNumColors ( char* pobj, int numcolors ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciSetGoodIndex(sciPointObj * pobj, int colorindex);  /* SET */
-GRAPHICS_IMPEXP void sciRecursiveUpdateBaW(sciPointObj *pobj, int old_m, int m);  /* SET */
-GRAPHICS_IMPEXP int sciUpdateBaW (sciPointObj * pobj, int flag, int value ) ; /* SET */
+GRAPHICS_IMPEXP int sciSetGoodIndex(char* pobj, int colorindex);  /* SET */
+GRAPHICS_IMPEXP void sciRecursiveUpdateBaW(char* pobj, int old_m, int m);  /* SET */
+GRAPHICS_IMPEXP int sciUpdateBaW (char* pobj, int flag, int value ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitBackground( sciPointObj * pobj, int colorindex ) ;
-GRAPHICS_IMPEXP int sciSetBackground ( sciPointObj * pobj, int colorindex ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitBackground( char* pobj, int colorindex ) ;
+GRAPHICS_IMPEXP int sciSetBackground ( char* pobj, int colorindex ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitForeground( sciPointObj * pobj, int colorindex ) ;
-GRAPHICS_IMPEXP int sciSetForeground ( sciPointObj * pobj, int colorindex ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitForeground( char* pobj, int colorindex ) ;
+GRAPHICS_IMPEXP int sciSetForeground ( char* pobj, int colorindex ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitLineWidth( sciPointObj * pobj, double linewidth ) ;
-GRAPHICS_IMPEXP int sciSetLineWidth ( sciPointObj * pobj, double linewidth ) ;  /* SET */
+GRAPHICS_IMPEXP int sciInitLineWidth( char* pobj, double linewidth ) ;
+GRAPHICS_IMPEXP int sciSetLineWidth ( char* pobj, double linewidth ) ;  /* SET */
 
-GRAPHICS_IMPEXP int sciInitIsLine(sciPointObj * pobj, BOOL isline);
-GRAPHICS_IMPEXP int sciSetIsLine (sciPointObj * pobj, BOOL isline);  /* SET */
+GRAPHICS_IMPEXP int sciInitIsLine(char* pobj, BOOL isline);
+GRAPHICS_IMPEXP int sciSetIsLine (char* pobj, BOOL isline);  /* SET */
 
-GRAPHICS_IMPEXP int sciInitLineStyle( sciPointObj * pobj, int linestyle ) ;
-GRAPHICS_IMPEXP int sciSetLineStyle ( sciPointObj * pobj, int linestyle ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitLineStyle( char* pobj, int linestyle ) ;
+GRAPHICS_IMPEXP int sciSetLineStyle ( char* pobj, int linestyle ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitIsMark(sciPointObj * pobj, BOOL ismark);  /* SET */
-GRAPHICS_IMPEXP int sciSetIsMark (sciPointObj * pobj, BOOL ismark);  /* SET */
+GRAPHICS_IMPEXP int sciInitIsMark(char* pobj, BOOL ismark);  /* SET */
+GRAPHICS_IMPEXP int sciSetIsMark (char* pobj, BOOL ismark);  /* SET */
 
-GRAPHICS_IMPEXP int sciInitIsFilled(sciPointObj * pobj, BOOL isfilled);
-GRAPHICS_IMPEXP int sciSetIsFilled (sciPointObj * pobj, BOOL isfilled);  /* SET */
+GRAPHICS_IMPEXP int sciInitIsFilled(char* pobj, BOOL isfilled);
+GRAPHICS_IMPEXP int sciSetIsFilled (char* pobj, BOOL isfilled);  /* SET */
 
-GRAPHICS_IMPEXP int sciInitPolylineStyle( sciPointObj * pobj, int plot );
-GRAPHICS_IMPEXP int sciInitArrowSize( sciPointObj * pobj, double size );
+GRAPHICS_IMPEXP int sciInitPolylineStyle( char* pobj, int plot );
+GRAPHICS_IMPEXP int sciInitArrowSize( char* pobj, double size );
 
-GRAPHICS_IMPEXP int sciInitMarkStyle(sciPointObj * pobj, int markstyle);
-GRAPHICS_IMPEXP int sciSetMarkStyle (sciPointObj * pobj, int markstyle); /* SET */
+GRAPHICS_IMPEXP int sciInitMarkStyle(char* pobj, int markstyle);
+GRAPHICS_IMPEXP int sciSetMarkStyle (char* pobj, int markstyle); /* SET */
 
-GRAPHICS_IMPEXP int sciInitMarkSize(sciPointObj * pobj, int marksize);
-GRAPHICS_IMPEXP int sciSetMarkSize (sciPointObj * pobj, int marksize); /* SET */
+GRAPHICS_IMPEXP int sciInitMarkSize(char* pobj, int marksize);
+GRAPHICS_IMPEXP int sciSetMarkSize (char* pobj, int marksize); /* SET */
 
-GRAPHICS_IMPEXP int sciInitMarkSizeUnit(sciPointObj * pobj, int marksizeunit);
-GRAPHICS_IMPEXP int sciSetMarkSizeUnit (sciPointObj * pobj, int marksizeunit); /* SET */
+GRAPHICS_IMPEXP int sciInitMarkSizeUnit(char* pobj, int marksizeunit);
+GRAPHICS_IMPEXP int sciSetMarkSizeUnit (char* pobj, int marksizeunit); /* SET */
 
-GRAPHICS_IMPEXP int sciInitMarkBackground(sciPointObj * pobj, int colorindex);
-GRAPHICS_IMPEXP int sciSetMarkBackground (sciPointObj * pobj, int colorindex);  /* SET */
+GRAPHICS_IMPEXP int sciInitMarkBackground(char* pobj, int colorindex);
+GRAPHICS_IMPEXP int sciSetMarkBackground (char* pobj, int colorindex);  /* SET */
 
-GRAPHICS_IMPEXP int sciInitMarkForeground(sciPointObj * pobj, int colorindex);
-GRAPHICS_IMPEXP int sciSetMarkForeground (sciPointObj * pobj, int colorindex);  /* SET */
+GRAPHICS_IMPEXP int sciInitMarkForeground(char* pobj, int colorindex);
+GRAPHICS_IMPEXP int sciSetMarkForeground (char* pobj, int colorindex);  /* SET */
 
-GRAPHICS_IMPEXP int sciInitBoxType( sciPointObj * pobj, EAxesBoxType type ) ;
-GRAPHICS_IMPEXP int sciSetBoxType ( sciPointObj * pobj, EAxesBoxType type ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitBoxType( char* pobj, EAxesBoxType type ) ;
+GRAPHICS_IMPEXP int sciSetBoxType ( char* pobj, EAxesBoxType type ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitIsBoxed(sciPointObj * pobj, BOOL isboxed);
-GRAPHICS_IMPEXP int sciSetIsBoxed (sciPointObj * pobj, BOOL isboxed); /* SET */
+GRAPHICS_IMPEXP int sciInitIsBoxed(char* pobj, BOOL isboxed);
+GRAPHICS_IMPEXP int sciSetIsBoxed (char* pobj, BOOL isboxed); /* SET */
 
-GRAPHICS_IMPEXP int sciInitNbXSubTics(sciPointObj * pobj, int nbsubtics);
-GRAPHICS_IMPEXP int sciSetNbXSubTics (sciPointObj * pobj, int nbsubtics); /* SET */
+GRAPHICS_IMPEXP int sciInitNbXSubTics(char* pobj, int nbsubtics);
+GRAPHICS_IMPEXP int sciSetNbXSubTics (char* pobj, int nbsubtics); /* SET */
 
-GRAPHICS_IMPEXP int sciInitNbYSubTics(sciPointObj * pobj, int nbsubtics);
-GRAPHICS_IMPEXP int sciSetNbYSubTics (sciPointObj * pobj, int nbsubtics); /* SET */
+GRAPHICS_IMPEXP int sciInitNbYSubTics(char* pobj, int nbsubtics);
+GRAPHICS_IMPEXP int sciSetNbYSubTics (char* pobj, int nbsubtics); /* SET */
 
-GRAPHICS_IMPEXP int sciInitNbZSubTics(sciPointObj * pobj, int nbsubtics);
-GRAPHICS_IMPEXP int sciSetNbZSubTics (sciPointObj * pobj, int nbsubtics); /* SET */
+GRAPHICS_IMPEXP int sciInitNbZSubTics(char* pobj, int nbsubtics);
+GRAPHICS_IMPEXP int sciSetNbZSubTics (char* pobj, int nbsubtics); /* SET */
 
 /* Text Functions */
-GRAPHICS_IMPEXP int sciInitFontSize(sciPointObj * pobj, double fontSize); /* SET */
-GRAPHICS_IMPEXP int sciSetFontSize (sciPointObj * pobj, double fontSize); /* SET */
+GRAPHICS_IMPEXP int sciInitFontSize(char* pobj, double fontSize); /* SET */
+GRAPHICS_IMPEXP int sciSetFontSize (char* pobj, double fontSize); /* SET */
 
-GRAPHICS_IMPEXP int sciInitFontOrientation(sciPointObj * pobj, double textorientation); /* SET */
-GRAPHICS_IMPEXP int sciSetFontOrientation (sciPointObj * pobj, double textorientation); /* SET */
+GRAPHICS_IMPEXP int sciInitFontOrientation(char* pobj, double textorientation); /* SET */
+GRAPHICS_IMPEXP int sciSetFontOrientation (char* pobj, double textorientation); /* SET */
 
-GRAPHICS_IMPEXP int sciSetStrings( sciPointObj * pobj, const StringMatrix * pStrings ) ; /* SET */
-GRAPHICS_IMPEXP int sciSetText (   sciPointObj * pobj, char ** text, int nbRow, int nbCol ) ; /* SET */
+GRAPHICS_IMPEXP int sciSetStrings( char* pobj, const StringMatrix * pStrings ) ; /* SET */
+GRAPHICS_IMPEXP int sciSetText (   char* pobj, char ** text, int nbRow, int nbCol ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitFontBackground(sciPointObj * pobj, int color);
-GRAPHICS_IMPEXP int sciSetFontBackground (sciPointObj * pobj, int color); /* SET */
+GRAPHICS_IMPEXP int sciInitFontBackground(char* pobj, int color);
+GRAPHICS_IMPEXP int sciSetFontBackground (char* pobj, int color); /* SET */
 
-GRAPHICS_IMPEXP int sciInitFontForeground(sciPointObj * pobj, int colorindex ) ;
-GRAPHICS_IMPEXP int sciSetFontForeground (sciPointObj * pobj, int colorindex ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitFontForeground(char* pobj, int colorindex ) ;
+GRAPHICS_IMPEXP int sciSetFontForeground (char* pobj, int colorindex ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitFontStyle(sciPointObj * pobj, int iAttributes ) ;
-GRAPHICS_IMPEXP int sciSetFontStyle (sciPointObj * pobj, int iAttributes ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitFontStyle(char* pobj, int iAttributes ) ;
+GRAPHICS_IMPEXP int sciSetFontStyle (char* pobj, int iAttributes ) ; /* SET */
 
 /* Legend */
-GRAPHICS_IMPEXP int sciInitLegendPlace(sciPointObj * pobj, sciLegendPlace place);
-GRAPHICS_IMPEXP int sciSetLegendPlace (sciPointObj * pobj, sciLegendPlace place); /* SET */
+GRAPHICS_IMPEXP int sciInitLegendPlace(char* pobj, sciLegendPlace place);
+GRAPHICS_IMPEXP int sciSetLegendPlace (char* pobj, sciLegendPlace place); /* SET */
 
-GRAPHICS_IMPEXP int sciInitLegendPos(sciPointObj * pobj, double position[]);
-GRAPHICS_IMPEXP int sciSetLegendPos (sciPointObj * pobj, double position[]); /* SET */
+GRAPHICS_IMPEXP int sciInitLegendPos(char* pobj, double position[]);
+GRAPHICS_IMPEXP int sciSetLegendPos (char* pobj, double position[]); /* SET */
 
 /* GMODE */
-GRAPHICS_IMPEXP int sciInitIsClipping(sciPointObj * pobj, int value) ;
-GRAPHICS_IMPEXP int sciSetIsClipping (sciPointObj * pobj, int value); /* SET */
+GRAPHICS_IMPEXP int sciInitIsClipping(char* pobj, int value) ;
+GRAPHICS_IMPEXP int sciSetIsClipping (char* pobj, int value); /* SET */
 
-GRAPHICS_IMPEXP int sciSetClipping (sciPointObj * pobj, double pclip[4] ); /* SET */
+GRAPHICS_IMPEXP int sciSetClipping (char* pobj, double pclip[4] ); /* SET */
 
-GRAPHICS_IMPEXP int sciInitAddPlot (sciPointObj * pobj, BOOL value);
-GRAPHICS_IMPEXP int sciSetAddPlot (sciPointObj * pobj, BOOL value); /* SET */
+GRAPHICS_IMPEXP int sciInitAddPlot (char* pobj, BOOL value);
+GRAPHICS_IMPEXP int sciSetAddPlot (char* pobj, BOOL value); /* SET */
 
-GRAPHICS_IMPEXP int sciInitAutoScale(sciPointObj * pobj, BOOL value);
-GRAPHICS_IMPEXP int sciSetAutoScale (sciPointObj * pobj, BOOL value); /* SET */
+GRAPHICS_IMPEXP int sciInitAutoScale(char* pobj, BOOL value);
+GRAPHICS_IMPEXP int sciSetAutoScale (char* pobj, BOOL value); /* SET */
 
-GRAPHICS_IMPEXP int sciInitZooming(sciPointObj * pobj, BOOL value);
-GRAPHICS_IMPEXP int sciSetZooming (sciPointObj * pobj, BOOL value); /* SET */
+GRAPHICS_IMPEXP int sciInitZooming(char* pobj, BOOL value);
+GRAPHICS_IMPEXP int sciSetZooming (char* pobj, BOOL value); /* SET */
 
-GRAPHICS_IMPEXP int sciInitXorMode(sciPointObj * pobj, int value);
-GRAPHICS_IMPEXP int sciSetXorMode (sciPointObj * pobj, int value); /* SET */
+GRAPHICS_IMPEXP int sciInitXorMode(char* pobj, int value);
+GRAPHICS_IMPEXP int sciSetXorMode (char* pobj, int value); /* SET */
 
-GRAPHICS_IMPEXP int sciInitVisibility (sciPointObj * pobj, BOOL value);
-GRAPHICS_IMPEXP int sciSetVisibility (sciPointObj * pobj, BOOL value); /* SET */
+GRAPHICS_IMPEXP int sciInitVisibility (char* pobj, BOOL value);
+GRAPHICS_IMPEXP int sciSetVisibility (char* pobj, BOOL value); /* SET */
 
-GRAPHICS_IMPEXP int sciInitResize(sciPointObj * pobj, BOOL value);
-GRAPHICS_IMPEXP int sciSetResize (sciPointObj * pobj, BOOL value); /* SET */
+GRAPHICS_IMPEXP int sciInitResize(char* pobj, BOOL value);
+GRAPHICS_IMPEXP int sciSetResize (char* pobj, BOOL value); /* SET */
 
 GRAPHICS_IMPEXP int sciSetDefaultValues (void); /* SET */
 
 
 /* Window Functions */
-GRAPHICS_IMPEXP int sciInitName(sciPointObj * pobj, char * newName); /* SET */
-GRAPHICS_IMPEXP int sciSetName (sciPointObj * pobj, char * newName); /* SET */
-GRAPHICS_IMPEXP int sciInitNum( sciPointObj * pobj, int value ) ;
-GRAPHICS_IMPEXP int sciSetNum ( sciPointObj * pobj, int value ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitName(char* pobj, char * newName); /* SET */
+GRAPHICS_IMPEXP int sciSetName (char* pobj, char * newName); /* SET */
+GRAPHICS_IMPEXP int sciInitNum( char* pobj, int value ) ;
+GRAPHICS_IMPEXP int sciSetNum ( char* pobj, int value ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitDimension( sciPointObj * pobj, int newWidth, int newHeight ) ;
-GRAPHICS_IMPEXP int sciSetDimension(  sciPointObj * pobj, int newWidth, int newHeight ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitDimension( char* pobj, int newWidth, int newHeight ) ;
+GRAPHICS_IMPEXP int sciSetDimension(  char* pobj, int newWidth, int newHeight ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitWindowDim( sciPointObj * pobj, int newWidth, int newHeight ) ;
-GRAPHICS_IMPEXP int sciSetWindowDim(  sciPointObj * pobj, int newWidth, int newHeight ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitWindowDim( char* pobj, int newWidth, int newHeight ) ;
+GRAPHICS_IMPEXP int sciSetWindowDim(  char* pobj, int newWidth, int newHeight ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitScreenPosition(sciPointObj * pobj, int pposx, int pposy);
-GRAPHICS_IMPEXP int sciSetScreenPosition( sciPointObj * pobj, int pposx, int pposy); /* SET */
+GRAPHICS_IMPEXP int sciInitScreenPosition(char* pobj, int pposx, int pposy);
+GRAPHICS_IMPEXP int sciSetScreenPosition( char* pobj, int pposx, int pposy); /* SET */
 
 
-GRAPHICS_IMPEXP void sciSelectFirstSubwin( sciPointObj * parentFigure ) ; /* SET */
+GRAPHICS_IMPEXP void sciSelectFirstSubwin( char* parentFigure ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitSelectedSubWin (sciPointObj * psubwinobj);
-GRAPHICS_IMPEXP int sciSetSelectedSubWin (sciPointObj * psubwinobj); /* SET */
+GRAPHICS_IMPEXP int sciInitSelectedSubWin (char* psubwinobj);
+GRAPHICS_IMPEXP int sciSetSelectedSubWin (char* psubwinobj); /* SET */
 
-GRAPHICS_IMPEXP int sciSetOriginalSubWin (sciPointObj * pfigure, sciPointObj * psubwin); /* SET */
+GRAPHICS_IMPEXP int sciSetOriginalSubWin (char* pfigure, char* psubwin); /* SET */
 
-GRAPHICS_IMPEXP int sciSetPoint(sciPointObj * pthis, double *tab, int *numrow, int *numcol); /* SET */
+GRAPHICS_IMPEXP int sciSetPoint(char* pthis, double *tab, int *numrow, int *numcol); /* SET */
 
 GRAPHICS_IMPEXP int sciSetdrawmode(BOOL mode); /* SET */
 GRAPHICS_IMPEXP int sciSwitchWindow(int winnum); /* SET */
@@ -184,107 +185,107 @@ GRAPHICS_IMPEXP int sciSwitchWindow(int winnum); /* SET */
 GRAPHICS_IMPEXP int sciInitUsedWindow( int winNum ) ; /* SET */
 GRAPHICS_IMPEXP int sciSetUsedWindow( int winNum ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciSetInterpVector(sciPointObj * pobj, int size, int * value);
+GRAPHICS_IMPEXP int sciSetInterpVector(char* pobj, int size, int * value);
 
-GRAPHICS_IMPEXP int sciInitAutoRotation( sciPointObj * pObj, BOOL value ) ;
-GRAPHICS_IMPEXP int sciSetAutoRotation ( sciPointObj * pObj, BOOL value ) ;
+GRAPHICS_IMPEXP int sciInitAutoRotation( char* pObj, BOOL value ) ;
+GRAPHICS_IMPEXP int sciSetAutoRotation ( char* pObj, BOOL value ) ;
 
-GRAPHICS_IMPEXP int sciInitAutoPosition( sciPointObj * pObj, BOOL value ) ;
-GRAPHICS_IMPEXP int sciSetAutoPosition ( sciPointObj * pObj, BOOL value ) ;
+GRAPHICS_IMPEXP int sciInitAutoPosition( char* pObj, BOOL value ) ;
+GRAPHICS_IMPEXP int sciSetAutoPosition ( char* pObj, BOOL value ) ;
 
-GRAPHICS_IMPEXP int sciInitAutoSize( sciPointObj * pObj, BOOL autoSize ) ;
-GRAPHICS_IMPEXP int sciSetAutoSize(  sciPointObj * pObj, BOOL autoSize ) ;
+GRAPHICS_IMPEXP int sciInitAutoSize( char* pObj, BOOL autoSize ) ;
+GRAPHICS_IMPEXP int sciSetAutoSize(  char* pObj, BOOL autoSize ) ;
 
-GRAPHICS_IMPEXP int sciInitAlignment( sciPointObj * pObj, sciTextAlignment align ) ;
-GRAPHICS_IMPEXP int sciSetAlignment(  sciPointObj * pObj, sciTextAlignment align ) ;
+GRAPHICS_IMPEXP int sciInitAlignment( char* pObj, sciTextAlignment align ) ;
+GRAPHICS_IMPEXP int sciSetAlignment(  char* pObj, sciTextAlignment align ) ;
 
-GRAPHICS_IMPEXP int sciInitUserSize( sciPointObj * pObj, double width, double height ) ;
-GRAPHICS_IMPEXP int sciSetUserSize(  sciPointObj * pObj, double width, double height ) ;
+GRAPHICS_IMPEXP int sciInitUserSize( char* pObj, double width, double height ) ;
+GRAPHICS_IMPEXP int sciSetUserSize(  char* pObj, double width, double height ) ;
 
-GRAPHICS_IMPEXP int sciInitCenterPos( sciPointObj * pObj, BOOL newCP ) ;
-GRAPHICS_IMPEXP int sciSetCenterPos(  sciPointObj * pObj, BOOL newCP ) ;
+GRAPHICS_IMPEXP int sciInitCenterPos( char* pObj, BOOL newCP ) ;
+GRAPHICS_IMPEXP int sciSetCenterPos(  char* pObj, BOOL newCP ) ;
 
-GRAPHICS_IMPEXP int sciInitIs3d( sciPointObj * pObj, BOOL is3d ) ;
-GRAPHICS_IMPEXP int sciSetIs3d(  sciPointObj * pObj, BOOL is3d ) ;
+GRAPHICS_IMPEXP int sciInitIs3d( char* pObj, BOOL is3d ) ;
+GRAPHICS_IMPEXP int sciSetIs3d(  char* pObj, BOOL is3d ) ;
 
-GRAPHICS_IMPEXP int sciInitSelectedObject( sciPointObj * pObj ) ;
-GRAPHICS_IMPEXP int sciSetSelectObject(    sciPointObj * pObj ) ;
+GRAPHICS_IMPEXP int sciInitSelectedObject( char* pObj ) ;
+GRAPHICS_IMPEXP int sciSetSelectObject(    char* pObj ) ;
 
-GRAPHICS_IMPEXP int sciInitHiddenColor( sciPointObj * pObj, int newColor ) ;
-GRAPHICS_IMPEXP int sciSetHiddenColor(  sciPointObj * pObj, int newColor ) ;
+GRAPHICS_IMPEXP int sciInitHiddenColor( char* pObj, int newColor ) ;
+GRAPHICS_IMPEXP int sciSetHiddenColor(  char* pObj, int newColor ) ;
 
-GRAPHICS_IMPEXP int sciInitHiddenAxisColor( sciPointObj * pObj, int newColor ) ;
-GRAPHICS_IMPEXP int sciSetHiddenAxisColor( sciPointObj * pObj, int newColor ) ;
+GRAPHICS_IMPEXP int sciInitHiddenAxisColor( char* pObj, int newColor ) ;
+GRAPHICS_IMPEXP int sciSetHiddenAxisColor( char* pObj, int newColor ) ;
 
-GRAPHICS_IMPEXP int setSubWinAngles( sciPointObj *psubwin, double theta, double alpha );
+GRAPHICS_IMPEXP int setSubWinAngles( char* psubwin, double theta, double alpha );
 GRAPHICS_IMPEXP int sciInitdrawmode( BOOL mode );
 
-GRAPHICS_IMPEXP int sciInitGraphicsStyle( sciPointObj * pobj, BOOL value );
+GRAPHICS_IMPEXP int sciInitGraphicsStyle( char* pobj, BOOL value );
 
-GRAPHICS_IMPEXP int sciInitGridStyle( sciPointObj * pObj, int xStyle, int yStyle, int zStyle ) ; 
-GRAPHICS_IMPEXP int sciSetGridStyle( sciPointObj * pObj, int xStyle, int yStyle, int zStyle ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitGridStyle( char* pObj, int xStyle, int yStyle, int zStyle ) ;
+GRAPHICS_IMPEXP int sciSetGridStyle( char* pObj, int xStyle, int yStyle, int zStyle ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciSetViewport(  sciPointObj * pObj, const int viewport[4] ) ; /* SET */
+GRAPHICS_IMPEXP int sciSetViewport(  char* pObj, const int viewport[4] ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitInfoMessage(sciPointObj * pObj, const char * newMessage);
-GRAPHICS_IMPEXP int sciSetInfoMessage( sciPointObj * pObj, const char * newMessage ) ; /* SET */
+GRAPHICS_IMPEXP int sciInitInfoMessage(char* pObj, const char * newMessage);
+GRAPHICS_IMPEXP int sciSetInfoMessage( char* pObj, const char * newMessage ) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitEventHandler( sciPointObj * pObj, char * name ) ;
-GRAPHICS_IMPEXP int sciSetEventHandler(  sciPointObj * pObj, char * name ) ;
+GRAPHICS_IMPEXP int sciInitEventHandler( char* pObj, char * name ) ;
+GRAPHICS_IMPEXP int sciSetEventHandler(  char* pObj, char * name ) ;
 
-GRAPHICS_IMPEXP int sciInitIsEventHandlerEnable( sciPointObj * pObj, BOOL enable ) ;
-GRAPHICS_IMPEXP int sciSetIsEventHandlerEnable(  sciPointObj * pObj, BOOL enable ) ;
+GRAPHICS_IMPEXP int sciInitIsEventHandlerEnable( char* pObj, BOOL enable ) ;
+GRAPHICS_IMPEXP int sciSetIsEventHandlerEnable(  char* pObj, BOOL enable ) ;
 
-GRAPHICS_IMPEXP int sciSetDataBounds( sciPointObj * pObj, double bounds[6] ) ; /* SET */
-GRAPHICS_IMPEXP int sciSetRealDataBounds(sciPointObj * pObj, const double bounds[6]); /* SET */
+GRAPHICS_IMPEXP int sciSetDataBounds( char* pObj, double bounds[6] ) ; /* SET */
+GRAPHICS_IMPEXP int sciSetRealDataBounds(char* pObj, const double bounds[6]); /* SET */
 
-GRAPHICS_IMPEXP int sciInitViewingAngles( sciPointObj * pObj, double alpha, double theta) ;
-GRAPHICS_IMPEXP int sciSetViewingAngles( sciPointObj * pObj, double alpha, double theta); /* SET */
+GRAPHICS_IMPEXP int sciInitViewingAngles( char* pObj, double alpha, double theta) ;
+GRAPHICS_IMPEXP int sciSetViewingAngles( char* pObj, double alpha, double theta); /* SET */
 
-GRAPHICS_IMPEXP int setInfoMessageWithRotationAngles(sciPointObj * pFigure, double alpha, double theta);
+GRAPHICS_IMPEXP int setInfoMessageWithRotationAngles(char* pFigure, double alpha, double theta);
 
-GRAPHICS_IMPEXP int sciInitPixmapMode(sciPointObj * pObj, BOOL onOrOff);
-GRAPHICS_IMPEXP int sciSetPixmapMode(sciPointObj * pObj, BOOL onOrOff); /* SET */
+GRAPHICS_IMPEXP int sciInitPixmapMode(char* pObj, BOOL onOrOff);
+GRAPHICS_IMPEXP int sciSetPixmapMode(char* pObj, BOOL onOrOff); /* SET */
 
-GRAPHICS_IMPEXP int sciInitTextPos( sciPointObj * pObj, double posX, double posY, double posZ);
-GRAPHICS_IMPEXP int sciSetTextPos( sciPointObj * pObj, double posX, double posY, double posZ);
+GRAPHICS_IMPEXP int sciInitTextPos( char* pObj, double posX, double posY, double posZ);
+GRAPHICS_IMPEXP int sciSetTextPos( char* pObj, double posX, double posY, double posZ);
 
-GRAPHICS_IMPEXP int sciInitLogFlags(sciPointObj * pObj, char logFlags[3]);
-GRAPHICS_IMPEXP int sciSetLogFlags(sciPointObj * pObj, char logFlags[3]) ; /* SET */
+GRAPHICS_IMPEXP int sciInitLogFlags(char* pObj, char logFlags[3]);
+GRAPHICS_IMPEXP int sciSetLogFlags(char* pObj, char logFlags[3]) ; /* SET */
 
-GRAPHICS_IMPEXP int sciInitAutoTicks(sciPointObj * pObj, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ);
-GRAPHICS_IMPEXP int sciSetAutoTicks(sciPointObj * pObj, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ); /* SET */
+GRAPHICS_IMPEXP int sciInitAutoTicks(char* pObj, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ);
+GRAPHICS_IMPEXP int sciSetAutoTicks(char* pObj, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ); /* SET */
 
-GRAPHICS_IMPEXP int sciSetZoomBox(sciPointObj * pObj, const double zoomBox[6]); /* SET */
+GRAPHICS_IMPEXP int sciSetZoomBox(char* pObj, const double zoomBox[6]); /* SET */
 
-GRAPHICS_IMPEXP int sciInitImmediateDrawingMode(sciPointObj * pObj, BOOL autoRedraw);
-GRAPHICS_IMPEXP int sciSetImmediateDrawingMode(sciPointObj * pObj, BOOL autoRedraw);
+GRAPHICS_IMPEXP int sciInitImmediateDrawingMode(char* pObj, BOOL autoRedraw);
+GRAPHICS_IMPEXP int sciSetImmediateDrawingMode(char* pObj, BOOL autoRedraw);
 
-GRAPHICS_IMPEXP int sciInitUseNurbs(sciPointObj * pObj, BOOL useNurbs);
-GRAPHICS_IMPEXP int sciSetUseNurbs(sciPointObj * pObj, BOOL useNurbs); /* SET */
+GRAPHICS_IMPEXP int sciInitUseNurbs(char* pObj, BOOL useNurbs);
+GRAPHICS_IMPEXP int sciSetUseNurbs(char* pObj, BOOL useNurbs); /* SET */
 
-GRAPHICS_IMPEXP int sciInitIsUsingFractionalMetrics(sciPointObj * pObj, BOOL useFractionalMetrics);
-GRAPHICS_IMPEXP int sciSetIsUsingFractionalMetrics(sciPointObj * pObj, BOOL useFractionalMetrics); /* SET */
+GRAPHICS_IMPEXP int sciInitIsUsingFractionalMetrics(char* pObj, BOOL useFractionalMetrics);
+GRAPHICS_IMPEXP int sciSetIsUsingFractionalMetrics(char* pObj, BOOL useFractionalMetrics); /* SET */
 
-GRAPHICS_IMPEXP int sciInitColorRange(sciPointObj * pObj, int subset[2]); 
-GRAPHICS_IMPEXP int sciSetColorRange(sciPointObj * pObj, int subset[2]); /* SET */
+GRAPHICS_IMPEXP int sciInitColorRange(char* pObj, int subset[2]);
+GRAPHICS_IMPEXP int sciSetColorRange(char* pObj, int subset[2]); /* SET */
 
-GRAPHICS_IMPEXP int sciInitOutsideColors(sciPointObj * pObj, int colors[2]);
-GRAPHICS_IMPEXP int sciSetOutsideColors(sciPointObj * pObj, int colors[2]); /* SET */
+GRAPHICS_IMPEXP int sciInitOutsideColors(char* pObj, int colors[2]);
+GRAPHICS_IMPEXP int sciSetOutsideColors(char* pObj, int colors[2]); /* SET */
 
-GRAPHICS_IMPEXP int sciInitZBounds(sciPointObj * pObj, double bounds[2]);
-GRAPHICS_IMPEXP int sciSetZBounds(sciPointObj * pObj, double bounds[2]); /* SET */
+GRAPHICS_IMPEXP int sciInitZBounds(char* pObj, double bounds[2]);
+GRAPHICS_IMPEXP int sciSetZBounds(char* pObj, double bounds[2]); /* SET */
 
-GRAPHICS_IMPEXP int sciInitGridFront(sciPointObj * pObj, BOOL gridFront);
-GRAPHICS_IMPEXP int sciSetGridFront(sciPointObj * pObj, BOOL gridFront); /* SET */
+GRAPHICS_IMPEXP int sciInitGridFront(char* pObj, BOOL gridFront);
+GRAPHICS_IMPEXP int sciSetGridFront(char* pObj, BOOL gridFront); /* SET */
 
-GRAPHICS_IMPEXP int sciInitLegendLocation(sciPointObj * pObj, sciLegendPlace location);
-GRAPHICS_IMPEXP int sciSetLegendLocation(sciPointObj * pObj, sciLegendPlace location); /* SET */
+GRAPHICS_IMPEXP int sciInitLegendLocation(char* pObj, sciLegendPlace location);
+GRAPHICS_IMPEXP int sciSetLegendLocation(char* pObj, sciLegendPlace location); /* SET */
 
-GRAPHICS_IMPEXP int sciInitAntialiasingQuality(sciPointObj * pObj, int quality);
-GRAPHICS_IMPEXP int sciSetAntialiasingQuality(sciPointObj * pObj, int quality); /* SET */
+GRAPHICS_IMPEXP int sciInitAntialiasingQuality(char* pObj, int quality);
+GRAPHICS_IMPEXP int sciSetAntialiasingQuality(char* pObj, int quality); /* SET */
 
-GRAPHICS_IMPEXP BOOL sciCheckColorIndex(sciPointObj * pObj, int colorIndex);
+GRAPHICS_IMPEXP BOOL sciCheckColorIndex(char* pObj, int colorIndex);
 
 /*---------------------------------------------------------------------------*/
 /* return 0 if the string contains any % character, 1 if a %d has been found */
index 6af4ec3..51c0615 100644 (file)
@@ -85,7 +85,7 @@ int sci_set(char *fname, unsigned long fname_len)
         size_t l3 = 0 ;
         unsigned long hdl;
         BOOL vis_save = FALSE ;
-        sciPointObj *pobj = NULL;
+        char *pobjUID = NULL;
 
         int valueType = 0 ; /* type of the rhs */
 
@@ -123,7 +123,7 @@ int sci_set(char *fname, unsigned long fname_len)
             }
 
             hdl = (long)*hstk(l1);
-            pobj = sciGetPointerFromHandle(hdl);
+            pobjUID = getObjectFromHandle(hdl);
 
             GetRhsVar(2,STRING_DATATYPE,&m2,&n2,&l2); /* Gets the command name */
 
@@ -177,7 +177,7 @@ int sci_set(char *fname, unsigned long fname_len)
             CheckRhs(2,2);
             GetRhsVar(1,STRING_DATATYPE,&m2,&n2,&l2);
             hdl = 0;
-            pobj = NULL;
+            pobjUID = NULL;
             valueType = VarType(2) ;
 
             if (valueType == sci_matrix )
@@ -214,17 +214,16 @@ int sci_set(char *fname, unsigned long fname_len)
 
         if ( hdl != 0 )
         {
-            sciPointObj * parentFigure;
-            pobj = sciGetPointerFromHandle(hdl);
+            pobjUID = getObjectFromHandle(hdl);
 
-            if ( pobj == NULL )
+            if ( pobjUID == NULL )
             {
                 Scierror(999,_("%s: The handle is not or no more valid.\n"),fname);
                 return 0;
             }
 
             // Only set the property whitout doing anythig else.
-            setStatus = sciSet(pobj, cstk(l2), &l3, valueType, &numrow3, &numcol3);
+            setStatus = sciSet(pobjUID, cstk(l2), &l3, valueType, &numrow3, &numcol3);
         }
        else
         {
index 98ac86f..3281a2f 100644 (file)
@@ -1027,382 +1027,367 @@ ConstructLegend (sciPointObj * pparentsubwin, char **text, long long tabofhandle
 /**
  * Create a polyline but does not add it to Scilab hierarchy
  */
-sciPointObj * allocatePolyline(sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pvecz,
-                               int closed, int n1,int plot, int *foreground, int *background,
-                               int *mark_style, int *mark_foreground, int *mark_background,
-                               BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
+char* allocatePolyline(char* pparentsubwinUID, double *pvecx, double *pvecy, double *pvecz,
+                       int closed, int n1,int plot, int *foreground, int *background,
+                       int *mark_style, int *mark_foreground, int *mark_background,
+                       BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
 {
-  sciPointObj * pobj = NULL;
-  int i = 0;
-  BOOL result;
-  char* type;
-  char* polylineID;
-  double barWidth;
-  double arrowSizeFactor;
-  double* clipRegion;
-  double* dataVector;
-  int clipState = 0;
-  int *piClipState = &clipState;
-  int lineClosed;
-  int numElementsArray[2];
-  int polylineStyle;
-  int visible = 0;
-  int* piVisible = &visible;
-  int zCoordinatesSet;
-  int* tmp;
-  int clipRegionSet = 0;
-  int *piClipRegionSet = &clipRegionSet;
-
-
-  getGraphicObjectProperty(pparentsubwin->UID, __GO_TYPE__, jni_string, &type);
-
-  if (strcmp(type, __GO_AXES__) != 0)
-  {
-    Scierror(999, _("The parent has to be a SUBWIN\n"));
-    return (sciPointObj *) NULL;
-  }
+    char* pobjUID = NULL;
+    int i = 0;
+    BOOL result;
+    char* type;
+    char* polylineID;
+    double barWidth;
+    double arrowSizeFactor;
+    double* clipRegion;
+    double* dataVector;
+    int clipState = 0;
+    int *piClipState = &clipState;
+    int lineClosed;
+    int numElementsArray[2];
+    int polylineStyle;
+    int visible = 0;
+    int* piVisible = &visible;
+    int zCoordinatesSet;
+    int* tmp;
+    int clipRegionSet = 0;
+    int *piClipRegionSet = &clipRegionSet;
 
-  if ((pobj = MALLOC ((sizeof (sciPointObj)))) == NULL)
-  {
-    return NULL;
-  }
 
-  pobj->UID = (char*) createGraphicObject(__GO_POLYLINE__);
+    getGraphicObjectProperty(pparentsubwinUID, __GO_TYPE__, jni_string, &type);
 
-  polylineID = (char*) createDataObject(pobj->UID, __GO_POLYLINE__);
+    if (strcmp(type, __GO_AXES__) != 0)
+    {
+        Scierror(999, _("The parent has to be a SUBWIN\n"));
+        return NULL;
+    }
 
-  if (polylineID == NULL)
-  {
-    deleteGraphicObject(pobj->UID);
-    FREE(pobj);
-    return (sciPointObj*) NULL;
-  }
+    pobjUID = (char*) createGraphicObject(__GO_POLYLINE__);
 
-  /* To be deleted */
+    polylineID = (char*) createDataObject(pobjUID, __GO_POLYLINE__);
+
+    if (polylineID == NULL)
+    {
+        deleteGraphicObject(pobjUID);
+        return NULL;
+    }
+
+    /* To be deleted */
 #if 0
-  /* Create the default relationShip */
-  createDefaultRelationShip(pobj);
+    /* Create the default relationShip */
+    createDefaultRelationShip(pobj);
 #endif
 
-  /* To be deleted */
+    /* To be deleted */
 #if 0
-  sciSetParent( pobj, pparentsubwin );
+    sciSetParent( pobj, pparentsubwin );
 #endif
 
-  /*
-   * Sets the polyline's parent in order to initialize the former's Contoured properties
-   * with the latter's values (sciInitGraphicContext call below)
-   */
-  setGraphicObjectProperty(pobj->UID, __GO_PARENT__, pparentsubwin->UID, jni_string, 1);
+    /*
+     * Sets the polyline's parent in order to initialize the former's Contoured properties
+     * with the latter's values (sciInitGraphicContext call below)
+     */
+    setGraphicObjectProperty(pobjUID, __GO_PARENT__, pparentsubwinUID, jni_string, 1);
 
 
-  barWidth = 0.0;
-  setGraphicObjectProperty(pobj->UID, __GO_BAR_WIDTH__, &barWidth, jni_double, 1);
+    barWidth = 0.0;
+    setGraphicObjectProperty(pobjUID, __GO_BAR_WIDTH__, &barWidth, jni_double, 1);
 
-  /* To be implemented */
+    /* To be implemented */
 #if 0
-  pPOLYLINE_FEATURE (pobj)->callback = (char *)NULL;
-  pPOLYLINE_FEATURE (pobj)->callbacklen = 0;
-  pPOLYLINE_FEATURE (pobj)->callbackevent = 100;
+    pPOLYLINE_FEATURE (pobj)->callback = (char *)NULL;
+    pPOLYLINE_FEATURE (pobj)->callbacklen = 0;
+    pPOLYLINE_FEATURE (pobj)->callbackevent = 100;
 #endif
 
-  getGraphicObjectProperty(pparentsubwin->UID, __GO_VISIBLE__, jni_bool, &piVisible);
+    getGraphicObjectProperty(pparentsubwinUID, __GO_VISIBLE__, jni_bool, &piVisible);
 
-  setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
+    setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
 
 
-  /* To be deleted, see the MVC corresponding calls below */
+    /* To be deleted, see the MVC corresponding calls below */
 #if 0
-  pPOLYLINE_FEATURE (pobj)->clip_region_set = 0;
-  sciInitIsClipping( pobj, sciGetIsClipping((sciPointObj *) sciGetParentSubwin(pobj)) ) ;
-  sciSetClipping(pobj,sciGetClipping(sciGetParentSubwin(pobj)));
+    pPOLYLINE_FEATURE (pobj)->clip_region_set = 0;
+    sciInitIsClipping( pobj, sciGetIsClipping((sciPointObj *) sciGetParentSubwin(pobj)) ) ;
+    sciSetClipping(pobj,sciGetClipping(sciGetParentSubwin(pobj)));
 #endif
 
-  /* Clip state and region */
-  /* To be checked for consistency */
+    /* Clip state and region */
+    /* To be checked for consistency */
 
-  getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
-  setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
+    getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX__, jni_double_vector, &clipRegion);
+    setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, clipRegion, jni_double_vector, 4);
 
-  getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
-  setGraphicObjectProperty(pobj->UID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
+    getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_BOX_SET__, jni_bool, &piClipRegionSet);
+    setGraphicObjectProperty(pobjUID, __GO_CLIP_BOX_SET__, &clipRegionSet, jni_bool, 1);
 
-  getGraphicObjectProperty(pparentsubwin->UID, __GO_CLIP_STATE__, jni_int, &piClipState);
-  setGraphicObjectProperty(pobj->UID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
+    getGraphicObjectProperty(pparentsubwinUID, __GO_CLIP_STATE__, jni_int, &piClipState);
+    setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
 
 
-  arrowSizeFactor = 1.0;
-  setGraphicObjectProperty(pobj->UID, __GO_ARROW_SIZE_FACTOR__, &arrowSizeFactor, jni_double, 1);
+    arrowSizeFactor = 1.0;
+    setGraphicObjectProperty(pobjUID, __GO_ARROW_SIZE_FACTOR__, &arrowSizeFactor, jni_double, 1);
 
-  /* To be implemented */
+    /* To be implemented */
 #if 0
-  pPOLYLINE_FEATURE (pobj)->isselected = TRUE;
+    pPOLYLINE_FEATURE (pobj)->isselected = TRUE;
 #endif
 
 
-  /*
-   * First element: number of gons (always 1 for a Polyline)
-   * Second one: number of vertices composing the Polyline
-   */
-  numElementsArray[0] = 1;
-  numElementsArray[1] = n1;
-
-  /* Data */
-  if ( n1 != 0 )
-  {
     /*
-     * Sets the number of elements (vertices composing the polyline) and allocates the coordinates array
-     * The FALSE value is used to identify a failed memory allocation for now.
+     * First element: number of gons (always 1 for a Polyline)
+     * Second one: number of vertices composing the Polyline
      */
-    result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
+    numElementsArray[0] = 1;
+    numElementsArray[1] = n1;
 
-    if (result == FALSE)
+    /* Data */
+    if ( n1 != 0 )
     {
-        deleteGraphicObject(pobj->UID);
-        deleteDataObject(pobj->UID);
-        FREE(pobj);
-        return (sciPointObj *) NULL;
-    }
+        /*
+         * Sets the number of elements (vertices composing the polyline) and allocates the coordinates array
+         * The FALSE value is used to identify a failed memory allocation for now.
+         */
+        result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
 
-    dataVector = MALLOC(3*n1*sizeof(double));
+        if (result == FALSE)
+        {
+            deleteGraphicObject(pobjUID);
+            deleteDataObject(pobjUID);
+            return NULL;
+        }
 
-    if (dataVector == NULL)
-    {
-        deleteGraphicObject(pobj->UID);
-        deleteDataObject(pobj->UID);
-        FREE(pobj);
-        return (sciPointObj *) NULL;
-    }
+        dataVector = MALLOC(3*n1*sizeof(double));
 
-    if ((pvecx != (double *)NULL)&&(pvecy != (double *)NULL))
-    {
-        for (i = 0; i < n1; i++)
+        if (dataVector == NULL)
         {
-            dataVector[i] = pvecx[i];
-            dataVector[n1+i] = pvecy[i];
+            deleteGraphicObject(pobjUID);
+            deleteDataObject(pobjUID);
+            return NULL;
         }
-    }
-    else
-    {
-        for (i = 0; i < n1; i++)
+
+        if ((pvecx != (double *)NULL)&&(pvecy != (double *)NULL))
         {
-            dataVector[i] = 0.0;
-            dataVector[n1+i] = 0.0;
+            for (i = 0; i < n1; i++)
+            {
+                dataVector[i] = pvecx[i];
+                dataVector[n1+i] = pvecy[i];
+            }
+        }
+        else
+        {
+            for (i = 0; i < n1; i++)
+            {
+                dataVector[i] = 0.0;
+                dataVector[n1+i] = 0.0;
+            }
         }
-    }
 
-    /**DJ.Abdemouche 2003**/
-    if (pvecz == NULL)
-    {
-        for (i = 0; i < n1; i++)
+        /**DJ.Abdemouche 2003**/
+        if (pvecz == NULL)
+        {
+            for (i = 0; i < n1; i++)
+            {
+                dataVector[2*n1+i] = 0.0;
+            }
+
+            zCoordinatesSet = 0;
+        }
+        else
         {
-            dataVector[2*n1+i] = 0.0;
+            for (i = 0; i < n1; i++)
+            {
+                dataVector[2*n1+i] = pvecz[i];
+            }
+
+            zCoordinatesSet = 1;
         }
 
-        zCoordinatesSet = 0;
+        /*
+         * We could probably do without the dataVector copy by individually setting
+         * x, y or z coordinates, and initializing coordinates to 0 during allocation
+         * to ensure consistency
+         */
+        setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_COORDINATES__, dataVector, jni_double, n1);
+
+        FREE(dataVector);
+
+        setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zCoordinatesSet, jni_double, n1);
     }
     else
     {
-        for (i = 0; i < n1; i++)
+        /* 0 points */
+        result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
+
+        if (result == FALSE)
         {
-            dataVector[2*n1+i] = pvecz[i];
+            deleteGraphicObject(pobjUID);
+            deleteDataObject(pobjUID);
+            return NULL;
         }
+    }
 
-        zCoordinatesSet = 1;
+    if (closed > 0)
+    {
+        lineClosed = 1;
+    }
+    else
+    {
+        lineClosed = 0;
     }
 
+    setGraphicObjectProperty(pobjUID, __GO_CLOSED__, &lineClosed, jni_bool, 1);
+    setGraphicObjectProperty(pobjUID, __GO_POLYLINE_STYLE__, &plot, jni_int, 1);
+
     /*
-     * We could probably do without the dataVector copy by individually setting
-     * x, y or z coordinates, and initializing coordinates to 0 during allocation
-     * to ensure consistency
+     * Initializes the contour properties (background, foreground, etc)
+     * to the default values (those of the parent Axes).
      */
-    setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_COORDINATES__, dataVector, jni_double, n1);
 
-    FREE(dataVector);
+    // FIXME ???
+    //sciInitGraphicContext(pobj);
 
-    setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zCoordinatesSet, jni_double, n1);
-  }
-  else
-  {
-      /* 0 points */
-      result = setGraphicObjectProperty(pobj->UID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
-
-      if (result == FALSE)
-      {
-          deleteGraphicObject(pobj->UID);
-          deleteDataObject(pobj->UID);
-          FREE(pobj);
-          return (sciPointObj *) NULL;
-      }
-  }
-
-  if (closed > 0)
-  {
-      lineClosed = 1;
-  }
-  else
-  {
-      lineClosed = 0;
-  }
-
-  setGraphicObjectProperty(pobj->UID, __GO_CLOSED__, &lineClosed, jni_bool, 1);
-  setGraphicObjectProperty(pobj->UID, __GO_POLYLINE_STYLE__, &plot, jni_int, 1);
-
-  /*
-   * Initializes the contour properties (background, foreground, etc)
-   * to the default values (those of the parent Axes).
-   */
-
-  sciInitGraphicContext(pobj);
-
-  /* To be deleted */
+    /* To be deleted */
 #if 0
-  if (sciInitGraphicContext (pobj) == -1)
-  {
-    FREE(pPOLYLINE_FEATURE (pobj)->pvy);
-    FREE(pPOLYLINE_FEATURE (pobj)->pvx);
-    FREE(pPOLYLINE_FEATURE(pobj));
-    FREE(pobj);
-    return (sciPointObj *) NULL;
-  }
+    if (sciInitGraphicContext (pobj) == -1)
+    {
+        FREE(pPOLYLINE_FEATURE (pobj)->pvy);
+        FREE(pPOLYLINE_FEATURE (pobj)->pvx);
+        FREE(pPOLYLINE_FEATURE(pobj));
+        FREE(pobj);
+        return NULL;
+    }
 #endif
 
   /* colors and marks setting */
-  setGraphicObjectProperty(pobj->UID, __GO_MARK_MODE__, &ismark, jni_bool, 1);
-  setGraphicObjectProperty(pobj->UID, __GO_LINE_MODE__, &isline, jni_bool, 1);
-  setGraphicObjectProperty(pobj->UID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
+    setGraphicObjectProperty(pobjUID, __GO_MARK_MODE__, &ismark, jni_bool, 1);
+    setGraphicObjectProperty(pobjUID, __GO_LINE_MODE__, &isline, jni_bool, 1);
+    setGraphicObjectProperty(pobjUID, __GO_FILL_MODE__, &isfilled, jni_bool, 1);
 
-  /* shading interpolation vector and mode */
-  setGraphicObjectProperty(pobj->UID, __GO_INTERP_COLOR_MODE__, &isinterpshaded, jni_bool, 1);
+    /* shading interpolation vector and mode */
+    setGraphicObjectProperty(pobjUID, __GO_INTERP_COLOR_MODE__, &isinterpshaded, jni_bool, 1);
 
-  if(foreground != NULL)
-  {
-      setGraphicObjectProperty(pobj->UID, __GO_LINE_COLOR__, foreground, jni_int, 1);
+    if(foreground != NULL)
+    {
+        setGraphicObjectProperty(pobjUID, __GO_LINE_COLOR__, foreground, jni_int, 1);
 
-      /* To be fully implemented within the MVC framework since it performs color range checks */
+        /* To be fully implemented within the MVC framework since it performs color range checks */
 #if 0
-      sciInitForeground(pobj,(*foreground));
+        sciInitForeground(pobj,(*foreground));
 #endif
-  }
+    }
 
-  if(background != NULL){
-      if(isinterpshaded == TRUE)
-      { /* 3 or 4 values to store */
+    if(background != NULL){
+        if(isinterpshaded == TRUE)
+        { /* 3 or 4 values to store */
 
-          setGraphicObjectProperty(pobj->UID, __GO_INTERP_COLOR_VECTOR__, background, jni_int_vector, n1);
+            setGraphicObjectProperty(pobjUID, __GO_INTERP_COLOR_VECTOR__, background, jni_int_vector, n1);
 
-          /* To be deleted */
+            /* To be deleted */
 #if 0
-          sciSetInterpVector(pobj,n1,background);
+            sciSetInterpVector(pobj,n1,background);
 #endif
-      }
-      else
-      {
-          setGraphicObjectProperty(pobj->UID, __GO_BACKGROUND__, background, jni_int, 1);
+        }
+        else
+        {
+            setGraphicObjectProperty(pobjUID, __GO_BACKGROUND__, background, jni_int, 1);
 
-    /* To be fully implemented within the MVC framework since it performs color range checks */
+            /* To be fully implemented within the MVC framework since it performs color range checks */
 #if 0
-          sciInitBackground(pobj,(*background));
+            sciInitBackground(pobj,(*background));
 #endif
-      }
-  }
+        }
+    }
 
-  if(mark_style != NULL)
-  {
-      /* This does use the MVC */
-      sciInitMarkStyle(pobj,(*mark_style));
-  }
+    if(mark_style != NULL)
+    {
+        /* This does use the MVC */
+#if 0
+        sciInitMarkStyle(pobj,(*mark_style));
+#endif
+    }
 
-  if(mark_foreground != NULL)
-  {
-    setGraphicObjectProperty(pobj->UID, __GO_MARK_FOREGROUND__, mark_foreground, jni_int, 1);
+    if(mark_foreground != NULL)
+    {
+        setGraphicObjectProperty(pobjUID, __GO_MARK_FOREGROUND__, mark_foreground, jni_int, 1);
 
-    /* To be fully implemented within the MVC framework since it performs color range checks */
+        /* To be fully implemented within the MVC framework since it performs color range checks */
 #if 0
-    sciInitMarkForeground(pobj,(*mark_foreground));
+        sciInitMarkForeground(pobj,(*mark_foreground));
 #endif
-  }
+    }
 
-  if(mark_background != NULL)
-  {
-    setGraphicObjectProperty(pobj->UID, __GO_MARK_BACKGROUND__, mark_background, jni_int, 1);
+    if(mark_background != NULL)
+    {
+        setGraphicObjectProperty(pobjUID, __GO_MARK_BACKGROUND__, mark_background, jni_int, 1);
 
-    /* To be fully implemented within the MVC framework since it performs color range checks */
+        /* To be fully implemented within the MVC framework since it performs color range checks */
 #if 0
-    sciInitMarkBackground(pobj,(*mark_background));
+        sciInitMarkBackground(pobj,(*mark_background));
 #endif
-  }
+    }
 
-  /* no sons for now */
-  /* To be deleted */
+    /* no sons for now */
+    /* To be deleted */
 #if 0
-  sciInitSelectedSons( pobj ) ;
+    sciInitSelectedSons( pobj ) ;
 
-  sciGetRelationship(pobj)->psons        = NULL ;
-  sciGetRelationship(pobj)->plastsons    = NULL ;
-  sciGetRelationship(pobj)->pSelectedSon = NULL ;
+    sciGetRelationship(pobj)->psons        = NULL ;
+    sciGetRelationship(pobj)->plastsons    = NULL ;
+    sciGetRelationship(pobj)->pSelectedSon = NULL ;
 #endif
 
-  /* Parent reset to the null object */
-  setGraphicObjectProperty(pobj->UID, __GO_PARENT__, "", jni_string, 1);
+    /* Parent reset to the null object */
+    setGraphicObjectProperty(pobjUID, __GO_PARENT__, "", jni_string, 1);
 
-  visible = 1;
-  setGraphicObjectProperty(pobj->UID, __GO_VISIBLE__, &visible, jni_bool, 1);
+    visible = 1;
+    setGraphicObjectProperty(pobjUID, __GO_VISIBLE__, &visible, jni_bool, 1);
 
-  /*
-   * Deactivated for now since not fully implemented yet by the MVC
-   * To be implemented
-   */
+    /*
+     * Deactivated for now since not fully implemented yet by the MVC
+     * To be implemented
+     */
 #if 0
-  initUserData(pobj);
+    initUserData(pobj);
 #endif
 
-  /*
-   * To be deleted
-   */
-  pobj->pObservers = NULL;
-
-  pobj->pDrawer = NULL;
-
-  return pobj;
-
+    return pobjUID;
 }
 /*---------------------------------------------------------------------------------*/
 /**ConstructPolyline
  * This function creates  Polyline 2d structure
  */
-sciPointObj *
-ConstructPolyline (sciPointObj * pparentsubwin, double *pvecx, double *pvecy, double *pvecz,
+char *ConstructPolyline (char *pparentsubwinUID, double *pvecx, double *pvecy, double *pvecz,
                   int closed, int n1,int plot, int *foreground, int *background,
                   int *mark_style, int *mark_foreground, int *mark_background,
-                  BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
+                         BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
 {
-  sciPointObj * pobj = allocatePolyline(pparentsubwin, pvecx, pvecy, pvecz, closed, n1, plot,
-                                        foreground, background, mark_style, mark_foreground, mark_background,
-                                        isline, isfilled, ismark, isinterpshaded);
+    char* pobjUID = allocatePolyline(pparentsubwinUID, pvecx, pvecy, pvecz, closed, n1, plot,
+                                     foreground, background, mark_style, mark_foreground, mark_background,
+                                     isline, isfilled, ismark, isinterpshaded);
 
-  if (pobj == NULL)
-  {
-    return NULL;
-  }
+    if (pobjUID == NULL)
+    {
+        return NULL;
+    }
 
-  /* allocatePolyline created a "fake" relationship, destroy it */
-  /*
-   * Deactivated since the sciPolyline struct is not used anymore
-   * and sciStandardBuildOperations uses the obsolete C hierarchical
-   * relationships.
-   * The operations still relevant are performed below
-   * (sciStandardBuildOperations should be updated as to include them).
-   */
+    /* allocatePolyline created a "fake" relationship, destroy it */
+    /*
+     * Deactivated since the sciPolyline struct is not used anymore
+     * and sciStandardBuildOperations uses the obsolete C hierarchical
+     * relationships.
+     * The operations still relevant are performed below
+     * (sciStandardBuildOperations should be updated as to include them).
+     */
 #if 0
-  FREE(pobj->relationShip);
+    FREE(pobj->relationShip);
 
-  if (sciStandardBuildOperations(pobj, pparentsubwin) == NULL)
-  {
-    FREE(pobj->pfeatures);
-    FREE(pobj);
-    return NULL;
-  }
+    if (sciStandardBuildOperations(pobj, pparentsubwin) == NULL)
+    {
+        FREE(pobj->pfeatures);
+        FREE(pobj);
+        return NULL;
+    }
 #endif
 
 
@@ -1414,14 +1399,13 @@ ConstructPolyline (sciPointObj * pparentsubwin, double *pvecx, double *pvecy, do
 //    return NULL;
 //  }
 
-  /*
-   * Sets the Axes as the polyline's parent and adds the polyline to
-   * its parent's list of children.
-   */
-  setGraphicObjectRelationship(pparentsubwin->UID, pobj->UID);
-
-  return pobj;
+    /*
+     * Sets the Axes as the polyline's parent and adds the polyline to
+     * its parent's list of children.
+     */
+    setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
 
+    return pobjUID;
 }
 
 
index 7a1540c..279f666 100644 (file)
@@ -271,6 +271,7 @@ int get_labels_arg(char *fname,int pos,rhs_opts opts[], char ** labels )
 
     /* jb silvy 03/2006 */
     /* do not change the legend if one already exists */
+#if 0
     sciPointObj * pSubWin = sciGetCurrentSubWin() ;
     if ( sciGetLegendDefined( pSubWin ) )
     {
@@ -280,6 +281,7 @@ int get_labels_arg(char *fname,int pos,rhs_opts opts[], char ** labels )
     {
       *labels = getDefLegend() ;
     }
+#endif
   }
   return 1;
 }
index de908aa..095e18d 100644 (file)
@@ -844,6 +844,9 @@ int InitAxesModel()
   char labelBuffer[LABEL_BUFFER_LENGTH];
   char** stringVector;
 
+  int lineColor = -1;
+  int background = -2;
+
   /*
    * Not needed any more since the MVC equivalent is now used
    * To be deleted
@@ -905,6 +908,10 @@ int InitAxesModel()
   setGraphicObjectProperty(paxesmdlUID, __GO_Z_AXIS_GRID_COLOR__, &gridColor, jni_int, 1);
 
   /* 0: background */
+   setGraphicObjectProperty(paxesmdlUID, __GO_LINE_COLOR__, &lineColor, jni_int, 1);
+   setGraphicObjectProperty(paxesmdlUID, __GO_BACKGROUND__, &background, jni_int, 1);
+
+
   gridPosition = 0;
 
   setGraphicObjectProperty(paxesmdlUID, __GO_GRID_POSITION__, &gridPosition, jni_int, 1);
index 82a6f4d..82c262e 100644 (file)
@@ -7,6 +7,7 @@
  * Copyright (C) 2008 - INRIA - Vincent COUVERT
  * Copyright (C) 2010-2011 - DIGITEO - Manuel Juliachs
  * Copyright (C) 2010 - Paul Griffiths
+ * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
  *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
 /* Modify the viewing angles of a subwindow                                           */
 /* for safer modifications prefer use Obj_RedrawNewAngle                              */
 /*---------------------------------------------------------------------------*/
-int setSubWinAngles( sciPointObj *psubwin, double theta, double alpha )
+int setSubWinAngles( char *psubwin, double theta, double alpha )
 {
-  /**dj20003***/
-  sciSubWindow * ppSubWin = pSUBWIN_FEATURE (psubwin) ;
+    // FIXME
+    abort();
+#if 0
+    /**dj20003***/
+    sciSubWindow * ppSubWin = pSUBWIN_FEATURE (psubwin) ;
 
-  ppSubWin->alpha = alpha ;
-  ppSubWin->theta = theta ;
+    ppSubWin->alpha = alpha ;
+    ppSubWin->theta = theta ;
 
-  if ((alpha == 0.0) && (theta == 270.0))
-  {
-    ppSubWin->is3d = FALSE ;
-    ppSubWin->project[2]= 0; /* no z to display */
-    return 0;
-  }
+    if ((alpha == 0.0) && (theta == 270.0))
+    {
+        ppSubWin->is3d = FALSE ;
+        ppSubWin->project[2]= 0; /* no z to display */
+        return 0;
+    }
 
-  ppSubWin->is3d  = TRUE  ;
-  if ((alpha == 0.0 ) || (alpha == 180.0 ) || (alpha == -180.0 ))  /* DJ.A 30/12 */
-  {
-    ppSubWin->project[2]= 0; /* no z to display */
-  }
-  else
-  {
-    ppSubWin->project[2]= 1; /* z must be displayed */
-    if (    ((alpha == 90.0 ) || (alpha == 270.0 ) || (alpha == -90.0 ) || (alpha == -270.0 ))
-        && ((theta == 90.0 ) || (theta == -90.0 ) || (theta == 270.0 ) || (theta == -270.0 )))
+    ppSubWin->is3d  = TRUE  ;
+    if ((alpha == 0.0 ) || (alpha == 180.0 ) || (alpha == -180.0 ))  /* DJ.A 30/12 */
     {
-      ppSubWin->project[1]= 0; /* no y to display */
+        ppSubWin->project[2]= 0; /* no z to display */
     }
     else
     {
-      ppSubWin->project[1]= 1;
-      if (   ( (alpha == 90.0 ) || (alpha == 270.0 ) || (alpha == -90.0  ) || (alpha == -270.0 ))
-          && ( (theta == 0.0  ) || (theta == 180.0 ) || (alpha == -180.0 ) ))
-      {
-        ppSubWin->project[0]= 0; /* BUG evreywhere when theta == 0 */
-      }
-      else
-      {
-        ppSubWin->project[0]= 1;
-      }
+        ppSubWin->project[2]= 1; /* z must be displayed */
+        if (    ((alpha == 90.0 ) || (alpha == 270.0 ) || (alpha == -90.0 ) || (alpha == -270.0 ))
+                && ((theta == 90.0 ) || (theta == -90.0 ) || (theta == 270.0 ) || (theta == -270.0 )))
+        {
+            ppSubWin->project[1]= 0; /* no y to display */
+        }
+        else
+        {
+            ppSubWin->project[1]= 1;
+            if (   ( (alpha == 90.0 ) || (alpha == 270.0 ) || (alpha == -90.0  ) || (alpha == -270.0 ))
+                   && ( (theta == 0.0  ) || (theta == 180.0 ) || (alpha == -180.0 ) ))
+            {
+                ppSubWin->project[0]= 0; /* BUG evreywhere when theta == 0 */
+            }
+            else
+            {
+                ppSubWin->project[0]= 1;
+            }
+        }
     }
-  }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /*---------------------------------------------------------------------------*/
@@ -123,33 +128,37 @@ int setSubWinAngles( sciPointObj *psubwin, double theta, double alpha )
 /* Modify the viewing angles of a subwindow and the one of its brothers id necessary  */
 /*---------------------------------------------------------------------------*/
 
-void Obj_RedrawNewAngle(sciPointObj * pSubwin, double alpha, double theta)
+void Obj_RedrawNewAngle(char * pSubwin, double alpha, double theta)
 {
-  /* check if all the axis must be turned */
-  sciPointObj * pParentFigure = sciGetParentFigure( pSubwin ) ;
-  if ( pFIGURE_FEATURE(pParentFigure)->rotstyle == 1 )
-  {
-    /* every axes has the same angles */
-    sciSons * subWins = sciGetSons( pParentFigure ) ;
+// FIXME
+    abort();
+#if 0
+    /* check if all the axis must be turned */
+    sciPointObj * pParentFigure = sciGetParentFigure( pSubwin ) ;
+    if ( pFIGURE_FEATURE(pParentFigure)->rotstyle == 1 )
+    {
+        /* every axes has the same angles */
+        sciSons * subWins = sciGetSons( pParentFigure ) ;
 
-    /* modify each axis */
-    while ( subWins != NULL )
+        /* modify each axis */
+        while ( subWins != NULL )
+        {
+            sciPointObj * curSubWin = subWins->pointobj ;
+            if ( curSubWin->entitytype == SCI_SUBWIN )
+            {
+                setSubWinAngles( curSubWin, theta, alpha ) ;
+                forceRedraw(curSubWin);
+            }
+            subWins = subWins->pnext ;
+        }
+    }
+    else
     {
-      sciPointObj * curSubWin = subWins->pointobj ;
-      if ( curSubWin->entitytype == SCI_SUBWIN )
-      {
-        setSubWinAngles( curSubWin, theta, alpha ) ;
-        forceRedraw(curSubWin);
-      }
-      subWins = subWins->pnext ;
+        /* modify angles only for this axes */
+        setSubWinAngles( pSubwin, theta, alpha ) ;
+        forceRedraw(pSubwin);
     }
-  }
-  else
-  {
-    /* modify angles only for this axes */
-    setSubWinAngles( pSubwin, theta, alpha ) ;
-    forceRedraw(pSubwin);
-  }
+#endif
 }
 
 
@@ -157,20 +166,25 @@ void Obj_RedrawNewAngle(sciPointObj * pSubwin, double alpha, double theta)
 
 
 /**sciSetEntityType
- * Sets the type of this Scilab graphic object (pobj)
+ * Sets the type of this Scilab graphic object (pobjUID)
  */
 int
-sciSetEntityType (sciPointObj * pobj, sciEntityType value)
+sciSetEntityType (char * pobjUID, sciEntityType value)
 {
-  if (pobj != (sciPointObj *) NULL)
-  {
-    pobj->entitytype = value ;
-    return 0 ;
-  }
-  else
-  {
-    return -1 ;
-  }
+// FIXME
+    abort();
+#if 0
+    if (pobj != (sciPointObj *) NULL)
+    {
+        pobj->entitytype = value ;
+        return 0 ;
+    }
+    else
+    {
+        return -1 ;
+    }
+#endif
+    return -1;
 }
 
 
@@ -181,316 +195,327 @@ sciSetEntityType (sciPointObj * pobj, sciEntityType value)
  * a[i] = RED, a[i+m] = GREEN, a[i+2*m] = BLUE
  */
 int
-sciSetColormap ( sciPointObj * pobj, double *rgbmat, int m, int n )
-{
-  int oldNbColors = sciGetNumColors(pobj) ;
-
-  if ( n != 3 )
-  {
-    Scierror(999, _("%s: Number of columns must be %d.\n"),"colormap",3);
-    return -1 ;
-  }
-
-  if ( SCI_FIGURE != sciGetEntityType(pobj) )
-  {
-    Scierror(999, _("%s: Object must be a %s.\n"),"sciSetColormap","SCI_FIGURE");
-    return -1 ;
-  }
-
-
-  pFIGURE_FEATURE(pobj)->numcolors = m ;
-
-  if ( pobj == getFigureModel() )
-  {
-    /* colormap is stored in the object */
-    FREE(pFIGURE_FEATURE(pobj)->pModelData->colorMap) ;
-    pFIGURE_FEATURE(pobj)->pModelData->colorMap = createDoubleArrayCopy(rgbmat, m * n ) ;
-    pFIGURE_FEATURE(pobj)->pModelData->numColors = m * n ;
-  }
-  else
-  {
-    sciSetJavaColormap( pobj, rgbmat, m * n ) ;
-    sciRecursiveUpdateBaW( pobj, oldNbColors, m ) ; /* missing line F.Leray */
-  }
-
-  return 0;
-}
-
-
-void sciRecursiveUpdateBaW(sciPointObj *pobj, int old_m, int m)
-{
-  sciSons *psonstmp;
-
-  sciSetNumColors (pobj,old_m);
-
-
-  if((sciGetEntityType(pobj) != SCI_AXES)        &&
-                !sciIsAutomaticallyRedrawn(pobj))
-    {
-      if(old_m +1 == sciGetForeground(pobj)) {   /* 0 => deals with Foreground */
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,0,-1); /* Black */
-       sciSetNumColors (pobj,old_m);
-      }
-      else  if(old_m +2 == sciGetForeground(pobj)) {
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,0,-2); /* White */
-       sciSetNumColors (pobj,old_m);
-      }
-      if(old_m +1 == sciGetBackground(pobj)) { /* 1 => deals with Background */
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,1,-1);
-       sciSetNumColors (pobj,old_m);
-      }
-      else if(old_m +2 == sciGetBackground(pobj)) {
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,1,-2);
-       sciSetNumColors (pobj,old_m);
-      }
-    }
-
-  if((sciGetEntityType(pobj) == SCI_TEXT)        ||
-     (sciGetEntityType(pobj) == SCI_SUBWIN)      ||
-     (sciGetEntityType(pobj) == SCI_LEGEND)      ||
-     (sciGetEntityType(pobj) == SCI_AXES)        ||
-     (sciGetEntityType(pobj) == SCI_FIGURE)      ||
-     (sciGetEntityType(pobj) == SCI_LABEL))
-    {
-      if(old_m +1 == sciGetFontForeground(pobj)) {
-       /* 2 => deals with FontForeground */
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,2,-1);
-       sciSetNumColors (pobj,old_m);
-      }
-      else  if(old_m +2 == sciGetFontForeground(pobj)) {
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,2,-2);
-       sciSetNumColors (pobj,old_m);
-      }
-
-      if(old_m +1 == sciGetFontBackground(pobj)) { /* 3 => deals with FontBackground */
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,3,-1);
-       sciSetNumColors (pobj,old_m);
-      }
-      else if(old_m +2 == sciGetFontBackground(pobj)) {
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,3,-2);
-       sciSetNumColors (pobj,old_m);
-      }
-    }
-
-
-  /* objects that can have marks */
-  if((sciGetEntityType(pobj) == SCI_FIGURE)    ||
-     (sciGetEntityType(pobj) == SCI_SUBWIN)    ||
-     (sciGetEntityType(pobj) == SCI_LEGEND)    ||
-     (sciGetEntityType(pobj) == SCI_ARC)       ||
-     (sciGetEntityType(pobj) == SCI_POLYLINE)  ||
-     (sciGetEntityType(pobj) == SCI_RECTANGLE) ||
-     (sciGetEntityType(pobj) == SCI_SURFACE)   ||
-     (sciGetEntityType(pobj) == SCI_AXES)      ||
-     (sciGetEntityType(pobj) == SCI_SEGS))
-    {
-      if(old_m +1 == sciGetMarkForeground(pobj)) {   /* 4 => deals with MarkForeground */
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,4,-1); /* Black */
-       sciSetNumColors (pobj,old_m);
-      }
-      else  if(old_m +2 == sciGetMarkForeground(pobj)) {
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,4,-2); /* White */
-       sciSetNumColors (pobj,old_m);
-      }
-      if(old_m +1 == sciGetMarkBackground(pobj)) { /* 5 => deals with MarkBackground */
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,5,-1);
-       sciSetNumColors (pobj,old_m);
-      }
-      else if(old_m +2 == sciGetMarkBackground(pobj)) {
-       sciSetNumColors (pobj,m);
-       sciUpdateBaW (pobj,5,-2);
-       sciSetNumColors (pobj,old_m);
-      }
-    }
-
-  sciSetNumColors (pobj,m); /* Add F.Leray 25.06.04 */
-
-  // ???
-  /* psonstmp = sciGetLastSons (pobj); */
-  /* while (psonstmp != (sciSons *) NULL) */
-  /*   { */
-  /*     sciRecursiveUpdateBaW(psonstmp->pointobj, old_m, m); */
-  /*     psonstmp = psonstmp->pprev; */
-  /*   } */
+sciSetColormap ( char * pobjUID, double *rgbmat, int m, int n )
+{
+    // FIXME
+    abort();
+#if 0
+    int oldNbColors = sciGetNumColors(pobjUID) ;
+
+    if ( n != 3 )
+    {
+        Scierror(999, _("%s: Number of columns must be %d.\n"),"colormap",3);
+        return -1 ;
+    }
+
+    if ( SCI_FIGURE != sciGetEntityType(pobjUID) )
+    {
+        Scierror(999, _("%s: Object must be a %s.\n"),"sciSetColormap","SCI_FIGURE");
+        return -1 ;
+    }
+
+
+    pFIGURE_FEATURE(pobjUID)->numcolors = m ;
+
+    if ( pobjUID == getFigureModel() )
+    {
+        /* colormap is stored in the object */
+        FREE(pFIGURE_FEATURE(pobjUID)->pModelData->colorMap) ;
+        pFIGURE_FEATURE(pobjUID)->pModelData->colorMap = createDoubleArrayCopy(rgbmat, m * n ) ;
+        pFIGURE_FEATURE(pobjUID)->pModelData->numColors = m * n ;
+    }
+    else
+    {
+        sciSetJavaColormap( pobjUID, rgbmat, m * n ) ;
+        sciRecursiveUpdateBaW( pobjUID, oldNbColors, m ) ; /* missing line F.Leray */
+    }
+#endif
+    return 0;
+}
+
+
+void sciRecursiveUpdateBaW(char *pobjUID, int old_m, int m)
+{
+    // FIXME
+    abort();
+#if 0
+    sciSons *psonstmp;
+
+    sciSetNumColors (pobjUID,old_m);
+
+
+    if((sciGetEntityType(pobjUID) != SCI_AXES)        &&
+       !sciIsAutomaticallyRedrawn(pobjUID))
+    {
+        if(old_m +1 == sciGetForeground(pobjUID)) {   /* 0 => deals with Foreground */
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,0,-1); /* Black */
+            sciSetNumColors (pobjUID,old_m);
+        }
+        else  if(old_m +2 == sciGetForeground(pobjUID)) {
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,0,-2); /* White */
+            sciSetNumColors (pobjUID,old_m);
+        }
+        if(old_m +1 == sciGetBackground(pobjUID)) { /* 1 => deals with Background */
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,1,-1);
+            sciSetNumColors (pobjUID,old_m);
+        }
+        else if(old_m +2 == sciGetBackground(pobjUID)) {
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,1,-2);
+            sciSetNumColors (pobjUID,old_m);
+        }
+    }
+
+    if((sciGetEntityType(pobjUID) == SCI_TEXT)        ||
+       (sciGetEntityType(pobjUID) == SCI_SUBWIN)      ||
+       (sciGetEntityType(pobjUID) == SCI_LEGEND)      ||
+       (sciGetEntityType(pobjUID) == SCI_AXES)        ||
+       (sciGetEntityType(pobjUID) == SCI_FIGURE)      ||
+       (sciGetEntityType(pobjUID) == SCI_LABEL))
+    {
+        if(old_m +1 == sciGetFontForeground(pobjUID)) {
+            /* 2 => deals with FontForeground */
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,2,-1);
+            sciSetNumColors (pobjUID,old_m);
+        }
+        else  if(old_m +2 == sciGetFontForeground(pobjUID)) {
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,2,-2);
+            sciSetNumColors (pobjUID,old_m);
+        }
+
+        if(old_m +1 == sciGetFontBackground(pobjUID)) { /* 3 => deals with FontBackground */
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,3,-1);
+            sciSetNumColors (pobjUID,old_m);
+        }
+        else if(old_m +2 == sciGetFontBackground(pobjUID)) {
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,3,-2);
+            sciSetNumColors (pobjUID,old_m);
+        }
+    }
+
+
+    /* objects that can have marks */
+    if((sciGetEntityType(pobjUID) == SCI_FIGURE)    ||
+       (sciGetEntityType(pobjUID) == SCI_SUBWIN)    ||
+       (sciGetEntityType(pobjUID) == SCI_LEGEND)    ||
+       (sciGetEntityType(pobjUID) == SCI_ARC)       ||
+       (sciGetEntityType(pobjUID) == SCI_POLYLINE)  ||
+       (sciGetEntityType(pobjUID) == SCI_RECTANGLE) ||
+       (sciGetEntityType(pobjUID) == SCI_SURFACE)   ||
+       (sciGetEntityType(pobjUID) == SCI_AXES)      ||
+       (sciGetEntityType(pobjUID) == SCI_SEGS))
+    {
+        if(old_m +1 == sciGetMarkForeground(pobjUID)) {   /* 4 => deals with MarkForeground */
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,4,-1); /* Black */
+            sciSetNumColors (pobjUID,old_m);
+        }
+        else  if(old_m +2 == sciGetMarkForeground(pobjUID)) {
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,4,-2); /* White */
+            sciSetNumColors (pobjUID,old_m);
+        }
+        if(old_m +1 == sciGetMarkBackground(pobjUID)) { /* 5 => deals with MarkBackground */
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,5,-1);
+            sciSetNumColors (pobjUID,old_m);
+        }
+        else if(old_m +2 == sciGetMarkBackground(pobjUID)) {
+            sciSetNumColors (pobjUID,m);
+            sciUpdateBaW (pobjUID,5,-2);
+            sciSetNumColors (pobjUID,old_m);
+        }
+    }
+
+    sciSetNumColors (pobjUID,m); /* Add F.Leray 25.06.04 */
+
+    // ???
+    /* psonstmp = sciGetLastSons (pobjUID); */
+    /* while (psonstmp != (sciSons *) NULL) */
+    /*   { */
+    /*     sciRecursiveUpdateBaW(psonstmp->pointobj, old_m, m); */
+    /*     psonstmp = psonstmp->pprev; */
+    /*   } */
+#endif
 }
 
 
 int
-sciUpdateBaW (sciPointObj * pobj, int flag, int value)
+sciUpdateBaW (char * pobjUID, int flag, int value)
 {
-  switch (flag)
+    switch (flag)
     {
     case 0: /* Foreground*/
-      switch (sciGetEntityType (pobj))
-       {
-       case SCI_POLYLINE:
-       case SCI_FIGURE:
-       case SCI_SUBWIN:
-       case SCI_ARC:
-       case SCI_SEGS:
-       case SCI_FEC:
-       case SCI_GRAYPLOT:
-       case SCI_RECTANGLE:
-       case SCI_SURFACE:
-       case SCI_AXES:
-       case SCI_LABEL: /* F.Leray 28.05.04 */
-       case SCI_TEXT:
-       case SCI_LEGEND:
-         sciSetForeground(pobj,value);
-         break;
-       case SCI_UIMENU:
-       case SCI_AGREG:
-       default:
-         return -1;
-         break;
-       }
-      break;
+        switch (sciGetEntityType (pobjUID))
+        {
+        case SCI_POLYLINE:
+        case SCI_FIGURE:
+        case SCI_SUBWIN:
+        case SCI_ARC:
+        case SCI_SEGS:
+        case SCI_FEC:
+        case SCI_GRAYPLOT:
+        case SCI_RECTANGLE:
+        case SCI_SURFACE:
+        case SCI_AXES:
+        case SCI_LABEL: /* F.Leray 28.05.04 */
+        case SCI_TEXT:
+        case SCI_LEGEND:
+            sciSetForeground(pobjUID,value);
+            break;
+        case SCI_UIMENU:
+        case SCI_AGREG:
+        default:
+            return -1;
+            break;
+        }
+        break;
     case 1: /* Background*/
-      switch (sciGetEntityType (pobj))
-       {
-       case SCI_FIGURE:
-       case SCI_SUBWIN:
-       case SCI_ARC:
-       case SCI_SEGS:
-       case SCI_FEC:
-       case SCI_GRAYPLOT:
-       case SCI_POLYLINE:
-       case SCI_RECTANGLE:
-       case SCI_SURFACE:
-       case SCI_AXES:
-       case SCI_LABEL: /* F.Leray 28.05.04 */
-       case SCI_TEXT:
-       case SCI_LEGEND:
-         sciSetBackground(pobj,value);
-         break;
-       case SCI_UIMENU:
-       case SCI_AGREG:
-       default:
-         return -1;
-         break;
-       }
-      break;
+        switch (sciGetEntityType (pobjUID))
+        {
+        case SCI_FIGURE:
+        case SCI_SUBWIN:
+        case SCI_ARC:
+        case SCI_SEGS:
+        case SCI_FEC:
+        case SCI_GRAYPLOT:
+        case SCI_POLYLINE:
+        case SCI_RECTANGLE:
+        case SCI_SURFACE:
+        case SCI_AXES:
+        case SCI_LABEL: /* F.Leray 28.05.04 */
+        case SCI_TEXT:
+        case SCI_LEGEND:
+            sciSetBackground(pobjUID,value);
+            break;
+        case SCI_UIMENU:
+        case SCI_AGREG:
+        default:
+            return -1;
+            break;
+        }
+        break;
     case 2: /* FontForeground*/
-      switch (sciGetEntityType (pobj))
-       {
-       case SCI_AXES:
-       case SCI_TEXT:
-       case SCI_LEGEND:
-       case SCI_FIGURE:
-       case SCI_SUBWIN:
-       case SCI_LABEL: /* F.Leray 28.05.04 */
-         sciSetFontForeground(pobj,value);
-         break;
-       default:
-         return -1;
-         break;
-       }
-      break;
+        switch (sciGetEntityType (pobjUID))
+        {
+        case SCI_AXES:
+        case SCI_TEXT:
+        case SCI_LEGEND:
+        case SCI_FIGURE:
+        case SCI_SUBWIN:
+        case SCI_LABEL: /* F.Leray 28.05.04 */
+            sciSetFontForeground(pobjUID,value);
+            break;
+        default:
+            return -1;
+            break;
+        }
+        break;
     case 3:
-      switch (sciGetEntityType (pobj))
-       {
-       case SCI_AXES:
-       case SCI_TEXT:
-       case SCI_LEGEND:
-       case SCI_FIGURE:
-       case SCI_SUBWIN:
-       case SCI_LABEL: /* F.Leray 28.05.04 */
-         sciSetFontBackground(pobj,value);
-         break;
-       case SCI_UIMENU:
-       default:
-         return -1;
-         break;
-       }
-      break;
+        switch (sciGetEntityType (pobjUID))
+        {
+        case SCI_AXES:
+        case SCI_TEXT:
+        case SCI_LEGEND:
+        case SCI_FIGURE:
+        case SCI_SUBWIN:
+        case SCI_LABEL: /* F.Leray 28.05.04 */
+            sciSetFontBackground(pobjUID,value);
+            break;
+        case SCI_UIMENU:
+        default:
+            return -1;
+            break;
+        }
+        break;
     case 4: /* MarkForeground*/
-      switch (sciGetEntityType (pobj))
-       {
-       case SCI_FIGURE:
-       case SCI_SUBWIN:
-       case SCI_LEGEND:
-       case SCI_ARC:
-       case SCI_POLYLINE:
-       case SCI_RECTANGLE:
-       case SCI_SURFACE:
-       case SCI_AXES:
-       case SCI_SEGS:
-         sciSetMarkForeground(pobj,value); /* F.Leray 21.01.05 */
-         break;
-       case SCI_UIMENU:
-       default:
-         return -1;
-         break;
-       }
-      break;
+        switch (sciGetEntityType (pobjUID))
+        {
+        case SCI_FIGURE:
+        case SCI_SUBWIN:
+        case SCI_LEGEND:
+        case SCI_ARC:
+        case SCI_POLYLINE:
+        case SCI_RECTANGLE:
+        case SCI_SURFACE:
+        case SCI_AXES:
+        case SCI_SEGS:
+            sciSetMarkForeground(pobjUID,value); /* F.Leray 21.01.05 */
+            break;
+        case SCI_UIMENU:
+        default:
+            return -1;
+            break;
+        }
+        break;
     case 5: /* MarkBackground*/
-      switch (sciGetEntityType (pobj))
-       {
-       case SCI_FIGURE:
-       case SCI_SUBWIN:
-       case SCI_LEGEND:
-       case SCI_ARC:
-       case SCI_POLYLINE:
-       case SCI_RECTANGLE:
-       case SCI_SURFACE:
-       case SCI_AXES:
-       case SCI_SEGS:
-         sciSetMarkBackground(pobj,value); /* F.Leray 21.01.05 */
-         break;
-       case SCI_UIMENU:
-       default:
-         return -1;
-         break;
-       }
-      break;
+        switch (sciGetEntityType (pobjUID))
+        {
+        case SCI_FIGURE:
+        case SCI_SUBWIN:
+        case SCI_LEGEND:
+        case SCI_ARC:
+        case SCI_POLYLINE:
+        case SCI_RECTANGLE:
+        case SCI_SURFACE:
+        case SCI_AXES:
+        case SCI_SEGS:
+            sciSetMarkBackground(pobjUID,value); /* F.Leray 21.01.05 */
+            break;
+        case SCI_UIMENU:
+        default:
+            return -1;
+            break;
+        }
+        break;
 
     default:
-      return -1;
-      break;
+        return -1;
+        break;
     }
 
-  return 0;
+    return 0;
 }
 
-int sciInitNumColors( sciPointObj * pobj, int numcolors)
+int sciInitNumColors( char * pobjUID, int numcolors)
 {
-
-  /* modified jb Silvy 06/2006 */
-       if (sciGetEntityType (pobj)==SCI_FIGURE)
-  {
-    pFIGURE_FEATURE(pobj)->numcolors = numcolors ;
-    return 0 ;
-  }else{
-    return sciSetNumColors( sciGetParentFigure( pobj ), numcolors ) ;
-  }
+    // FIXME
+    abort();
+#if 0
+    /* modified jb Silvy 06/2006 */
+       if (sciGetEntityType (pobjUID)==SCI_FIGURE)
+    {
+        pFIGURE_FEATURE(pobjUID)->numcolors = numcolors ;
+        return 0 ;
+    }else{
+        return sciSetNumColors( sciGetParentFigure( pobjUID ), numcolors ) ;
+    }
+#endif
+    return 0;
 }
 
 /**sciSetNumColors
  * This function sets the number of the color defined in colormap
- * param sciPointObj * pobj: the pointer to the entity
+ * param char * pobjUID: the pointer to the entity
  * param int numcolor: the number of the indexed color
  * return 0 if ok, -1 if not
  */
 int
-sciSetNumColors (sciPointObj * pobj, int numcolors)
+sciSetNumColors (char * pobjUID, int numcolors)
 {
-  if ( sciGetNumColors( pobj ) == numcolors )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitNumColors( pobj, numcolors ) ;
+    if ( sciGetNumColors( pobjUID ) == numcolors )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitNumColors( pobjUID, numcolors ) ;
 
 }
 
@@ -498,108 +523,112 @@ sciSetNumColors (sciPointObj * pobj, int numcolors)
 /*** Adding F.Leray 31.03.04 for supporting -1 and -2 indexes.*/
 /* retrieve the realindex inside the colormap from the handle color property */
 /* -1 is actually m+1 and -2, m+2 */
-int sciSetGoodIndex(sciPointObj * pobj, int colorindex) /* return colorindex or m (Default Black) or m+1 (Default White)*/
+int sciSetGoodIndex(char * pobjUID, int colorindex) /* return colorindex or m (Default Black) or m+1 (Default White)*/
 {
-  int m = sciGetNumColors (pobj);      /* the number of the color*/
+    int m = sciGetNumColors (pobjUID); /* the number of the color*/
 
-  if( colorindex == -1 ) /* Black */
-    return m + 1 ; /* modif. ici*/
-  else if( colorindex == -2 ) /* White */
-    return m + 2 ; /* modif. ici*/
-  else
-    return colorindex;
+    if( colorindex == -1 ) /* Black */
+        return m + 1 ; /* modif. ici*/
+    else if( colorindex == -2 ) /* White */
+        return m + 2 ; /* modif. ici*/
+    else
+        return colorindex;
 }
 
-int sciInitBackground( sciPointObj * pobj, int colorindex )
+int sciInitBackground( char * pobjUID, int colorindex )
 {
-  int m = sciGetNumColors(pobj);
-  if(!sciCheckColorIndex(pobj, colorindex)) return 0;
-
-  colorindex = sciSetGoodIndex(pobj,colorindex);
+    int m = sciGetNumColors(pobjUID);
+    if(!sciCheckColorIndex(pobjUID, colorindex)) return 0;
 
-  if (sciGetGraphicContext(pobj) != NULL)
-  {
-    int newIndex = Max (0, Min (colorindex - 1, m + 1));
-    sciGetGraphicContext(pobj)->backgroundcolor = newIndex;
+    colorindex = sciSetGoodIndex(pobjUID,colorindex);
 
-    if (sciGetEntityType(pobj) == SCI_FIGURE && !isFigureModel(pobj->UID))
+    if (sciGetGraphicContext(pobjUID) != NULL)
     {
+        int newIndex = Max (0, Min (colorindex - 1, m + 1));
+        sciGetGraphicContext(pobjUID)->backgroundcolor = newIndex;
+
+        if (sciGetEntityType(pobjUID) == SCI_FIGURE && !isFigureModel(pobjUID))
+        {
                        /* disable protection since this function will call Java */
-                 disableFigureSynchronization(pobj);
-      sciSetJavaBackground(pobj, newIndex);
-                       enableFigureSynchronization(pobj);
-    }
+            disableFigureSynchronization(pobjUID);
+            sciSetJavaBackground(pobjUID, newIndex);
+                       enableFigureSynchronization(pobjUID);
+        }
 
-    return 0;
-  }
+        return 0;
+    }
 
-  /*printSetGetErrorMessage("background");*/ /* rewrite updatebaw to renable this message */
-  return -1;
+    /*printSetGetErrorMessage("background");*/ /* rewrite updatebaw to renable this message */
+    return -1;
 }
 
 /**sciSetBackground
  * Sets the number of the Background
  */
 int
-sciSetBackground (sciPointObj * pobj, int colorindex)
+sciSetBackground (char * pobjUID, int colorindex)
 {
-  if ( sciGetBackground( pobj ) == colorindex )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( sciGetBackground( pobjUID ) == colorindex )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 
-  return sciInitBackground( pobj, colorindex ) ;
+    return sciInitBackground( pobjUID, colorindex ) ;
 
 }
 
 
-int sciInitForeground( sciPointObj * pobj, int colorindex )
+int sciInitForeground( char * pobjUID, int colorindex )
 {
-  int m = sciGetNumColors(pobj);
-  if(!sciCheckColorIndex(pobj, colorindex)) return 0;
+    // FIXME
+    abort();
+#if 0
+    int m = sciGetNumColors(pobjUID);
+    if(!sciCheckColorIndex(pobjUID, colorindex)) return 0;
 
-  colorindex = sciSetGoodIndex(pobj,colorindex);
+    colorindex = sciSetGoodIndex(pobjUID,colorindex);
 
-  if (sciGetGraphicContext(pobj) != NULL)
-  {
-    sciGetGraphicContext(pobj)->foregroundcolor = Max (0, Min (colorindex - 1, m + 1));
-    return 0;
-  }
+    if (sciGetGraphicContext(pobjUID) != NULL)
+    {
+        sciGetGraphicContext(pobjUID)->foregroundcolor = Max (0, Min (colorindex - 1, m + 1));
+        return 0;
+    }
 
-  /*printSetGetErrorMessage("foreground");*/ /* rewrite updatebaw to renable this message */
-  return -1;
+    /*printSetGetErrorMessage("foreground");*/ /* rewrite updatebaw to renable this message */
+#endif
+    return -1;
 }
 
 /**sciSetForeground
  * sets the number of the Foreground
  */
 int
-sciSetForeground (sciPointObj * pobj, int colorindex)
+sciSetForeground (char * pobjUID, int colorindex)
 {
-  if ( sciGetForeground( pobj ) == colorindex )
-  {
-    return 1 ;
-  }
-  return sciInitForeground( pobj, colorindex ) ;
+    if ( sciGetForeground( pobjUID ) == colorindex )
+    {
+        return 1 ;
+    }
+    return sciInitForeground( pobjUID, colorindex ) ;
 
 }
 
-int sciSetLineWidth( sciPointObj * pobj, double linewidth )
+int sciSetLineWidth( char * pobjUID, double linewidth )
 {
 /*
  * Deactivated: the property is set within the MVC regardless of its
  * currently stored value.
  */
 #if 0
-  if ( sciGetLineWidth( pobj ) == linewidth )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( sciGetLineWidth( pobjUID ) == linewidth )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 #endif
 
-  return sciInitLineWidth( pobj, linewidth ) ;
+    return sciInitLineWidth( pobjUID, linewidth ) ;
 }
 
 
@@ -607,84 +636,84 @@ int sciSetLineWidth( sciPointObj * pobj, double linewidth )
  * Sets the line width
  */
 int
-sciInitLineWidth (sciPointObj * pobj, double linewidth)
+sciInitLineWidth (char * pobjUID, double linewidth)
 {
-  BOOL status;
+    BOOL status;
 
-  if (linewidth < 0)
+    if (linewidth < 0)
     {
-      Scierror(999, _("Line width must be greater than %d.\n"),0);
-      return -1;
+        Scierror(999, _("Line width must be greater than %d.\n"),0);
+        return -1;
     }
-  else
-  {
-    status = setGraphicObjectProperty(pobj->UID, __GO_LINE_THICKNESS__, &linewidth, jni_double, 1);
-
-    if (status == TRUE)
+    else
     {
-      return 0;
+        status = setGraphicObjectProperty(pobjUID, __GO_LINE_THICKNESS__, &linewidth, jni_double, 1);
+
+        if (status == TRUE)
+        {
+            return 0;
+        }
     }
-  }
-  printSetGetErrorMessage("thickness");
-  return -1;
+    printSetGetErrorMessage("thickness");
+    return -1;
 }
 
 
-int sciSetLineStyle( sciPointObj * pobj, int linestyle )
+int sciSetLineStyle( char * pobjUID, int linestyle )
 {
 /*
  * Deactivated: the property is set within the MVC regardless of its
  * currently stored value.
  */
 #if 0
-  if ( sciGetLineStyle( pobj ) == linestyle )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( sciGetLineStyle( pobjUID ) == linestyle )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 #endif
 
-  return sciInitLineStyle( pobj, linestyle ) ;
+    return sciInitLineStyle( pobjUID, linestyle ) ;
 }
 
 /**sciSetLineStyle
  * Sets the line style
  */
 int
-sciInitLineStyle (sciPointObj * pobj, int linestyle)
+sciInitLineStyle (char * pobjUID, int linestyle)
 {
-  BOOL status;
-  if (linestyle < 0)
+    BOOL status;
+    if (linestyle < 0)
     {
-      Scierror(999, _("The line style must be greater than %d.\n"),0);
-      return -1;
+        Scierror(999, _("The line style must be greater than %d.\n"),0);
+        return -1;
     }
-  else
-  {
-    status = setGraphicObjectProperty(pobj->UID, __GO_LINE_STYLE__, &linestyle, jni_int, 1);
-
-    if (status == TRUE)
+    else
     {
-      return 0;
+        status = setGraphicObjectProperty(pobjUID, __GO_LINE_STYLE__, &linestyle, jni_int, 1);
+
+        if (status == TRUE)
+        {
+            return 0;
+        }
     }
-  }
 
-  printSetGetErrorMessage("line_style");
-  return -1;
+    printSetGetErrorMessage("line_style");
+    return -1;
 }
 
 
-int sciInitIsMark( sciPointObj * pobj, BOOL ismark )
+int sciInitIsMark( char * pobjUID, BOOL ismark )
 {
 
-  if (sciGetGraphicContext(pobj) != NULL)
-  {
-    sciGetGraphicContext(pobj)->ismark = ismark;
-    return 0;
-  }
+    if (sciGetGraphicContext(pobjUID) != NULL)
+    {
+        sciGetGraphicContext(pobjUID)->ismark = ismark;
+        return 0;
+    }
 
-  printSetGetErrorMessage("mark_mode");
-  return -1;
+    printSetGetErrorMessage("mark_mode");
+    return -1;
 
 }
 
@@ -692,33 +721,33 @@ int sciInitIsMark( sciPointObj * pobj, BOOL ismark )
  * Sets the line style
  */
 int
-sciSetIsMark (sciPointObj * pobj, BOOL ismark)
+sciSetIsMark (char * pobjUID, BOOL ismark)
 {
 
-  if ( sciGetIsMark(pobj) == ismark )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitIsMark( pobj, ismark ) ;
+    if ( sciGetIsMark(pobjUID) == ismark )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitIsMark( pobjUID, ismark ) ;
 
 }
 
 
-int sciInitMarkForeground( sciPointObj * pobj, int colorindex )
+int sciInitMarkForeground( char * pobjUID, int colorindex )
 {
-  if(!sciCheckColorIndex(pobj, colorindex)) return 0;
-  colorindex = sciSetGoodIndex(pobj,colorindex); /* Adding F.Leray 31.03.04*/
+    if(!sciCheckColorIndex(pobjUID, colorindex)) return 0;
+    colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
 
-  if (sciGetGraphicContext(pobj) != NULL)
-  {
-    sciGetGraphicContext(pobj)->markforeground =
-      Max (-1, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-    return 0;
-  }
+    if (sciGetGraphicContext(pobjUID) != NULL)
+    {
+        sciGetGraphicContext(pobjUID)->markforeground =
+            Max (-1, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        return 0;
+    }
 
-  printSetGetErrorMessage("mark_foreground");
-  return -1;
+    printSetGetErrorMessage("mark_foreground");
+    return -1;
 
 }
 
@@ -726,76 +755,76 @@ int sciInitMarkForeground( sciPointObj * pobj, int colorindex )
  * sets the number of the Marks'Foreground
  */
 int
-sciSetMarkForeground (sciPointObj * pobj, int colorindex)
+sciSetMarkForeground (char * pobjUID, int colorindex)
 {
 
-  colorindex = sciSetGoodIndex(pobj,colorindex); /* Adding F.Leray 31.03.04*/
-  if ( sciGetMarkForeground( pobj ) == colorindex )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitMarkForeground( pobj, colorindex ) ;
+    colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
+    if ( sciGetMarkForeground( pobjUID ) == colorindex )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitMarkForeground( pobjUID, colorindex ) ;
 
 }
 
-int sciInitMarkBackground( sciPointObj * pobj, int colorindex )
+int sciInitMarkBackground( char * pobjUID, int colorindex )
 {
-  if(!sciCheckColorIndex(pobj, colorindex)) return 0;
-  colorindex = sciSetGoodIndex(pobj,colorindex); /* Adding F.Leray 31.03.04*/
+    if(!sciCheckColorIndex(pobjUID, colorindex)) return 0;
+    colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
 
-  if (sciGetGraphicContext(pobj) != NULL)
-  {
-    sciGetGraphicContext(pobj)->markbackground =
-      Max (-1, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-    return 0;
-  }
+    if (sciGetGraphicContext(pobjUID) != NULL)
+    {
+        sciGetGraphicContext(pobjUID)->markbackground =
+            Max (-1, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        return 0;
+    }
 
-  printSetGetErrorMessage("mark_background");
-  return -1;
+    printSetGetErrorMessage("mark_background");
+    return -1;
 }
 
 /**sciSetMarkBackground
  * sets the number of the Marks'Background
  */
 int
-sciSetMarkBackground (sciPointObj * pobj, int colorindex)
+sciSetMarkBackground (char * pobjUID, int colorindex)
 {
 
-  colorindex = sciSetGoodIndex(pobj,colorindex); /* Adding F.Leray 31.03.04*/
+    colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
 
-  if ( sciGetMarkBackground( pobj ) == colorindex )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitMarkBackground( pobj, colorindex ) ;
+    if ( sciGetMarkBackground( pobjUID ) == colorindex )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitMarkBackground( pobjUID, colorindex ) ;
 
 }
 
 
 
-int sciInitMarkStyle( sciPointObj * pobj, int markstyle )
+int sciInitMarkStyle( char * pobjUID, int markstyle )
 {
-  BOOL status;
-
-  if (markstyle < 0 || markstyle > MAX_MARK_STYLE )
-  {
-    Scierror(999, _("Wrong value for '%s' property: Must be between %d and %d.\n"), "mark_style", 0, MAX_MARK_STYLE);
-    return -1;
-  }
-  else
-  {
-    status = setGraphicObjectProperty(pobj->UID, __GO_MARK_STYLE__, &markstyle, jni_int, 1);
+    BOOL status;
 
-    if (status == TRUE)
+    if (markstyle < 0 || markstyle > MAX_MARK_STYLE )
+    {
+        Scierror(999, _("Wrong value for '%s' property: Must be between %d and %d.\n"), "mark_style", 0, MAX_MARK_STYLE);
+        return -1;
+    }
+    else
     {
-      return 0;
+        status = setGraphicObjectProperty(pobjUID, __GO_MARK_STYLE__, &markstyle, jni_int, 1);
+
+        if (status == TRUE)
+        {
+            return 0;
+        }
     }
-  }
 
-  printSetGetErrorMessage("mark_style");
-  return -1;
+    printSetGetErrorMessage("mark_style");
+    return -1;
 }
 
 
@@ -803,85 +832,85 @@ int sciInitMarkStyle( sciPointObj * pobj, int markstyle )
  * Sets the mark style
  */
 int
-sciSetMarkStyle (sciPointObj * pobj, int markstyle)
+sciSetMarkStyle (char * pobjUID, int markstyle)
 {
 /*
  * Deactivated: the property is set within the MVC regardless of its
  * currently stored value.
  */
 #if 0
-  if ( sciGetMarkStyle( pobj ) == markstyle )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( sciGetMarkStyle( pobjUID ) == markstyle )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 #endif
 
-  return sciInitMarkStyle( pobj, markstyle ) ;
+    return sciInitMarkStyle( pobjUID, markstyle ) ;
 }
 
-int sciInitMarkSize( sciPointObj * pobj, int marksize )
+int sciInitMarkSize( char * pobjUID, int marksize )
 {
-  if (marksize < 0)
-  {
-    Scierror(999, _("The mark size must be greater or equal than %d.\n"),0);
-    return -1;
-  }
-  else
-  {
-    BOOL status;
+    if (marksize < 0)
+    {
+        Scierror(999, _("The mark size must be greater or equal than %d.\n"),0);
+        return -1;
+    }
+    else
+    {
+        BOOL status;
 
-    status = setGraphicObjectProperty(pobj->UID, __GO_MARK_SIZE__, &marksize, jni_int, 1);
+        status = setGraphicObjectProperty(pobjUID, __GO_MARK_SIZE__, &marksize, jni_int, 1);
 
-    if (status == TRUE)
-    {
-      return 0;
+        if (status == TRUE)
+        {
+            return 0;
+        }
     }
-  }
 
-  printSetGetErrorMessage("mark_size");
-  return -1;
+    printSetGetErrorMessage("mark_size");
+    return -1;
 }
 
 /**sciSetMarkSize
  * Sets the mark size
  */
 int
-sciSetMarkSize (sciPointObj * pobj, int marksize)
+sciSetMarkSize (char * pobjUID, int marksize)
 {
 /*
  * Deactivated: the property is set within the MVC regardless of its
  * currently stored value.
  */
 #if 0
-  if ( sciGetMarkSize( pobj ) == marksize )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( sciGetMarkSize( pobjUID ) == marksize )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 #endif
 
-  return sciInitMarkSize( pobj, marksize ) ;
+    return sciInitMarkSize( pobjUID, marksize ) ;
 }
 
-int sciInitMarkSizeUnit( sciPointObj * pobj, int marksizeunit )
+int sciInitMarkSizeUnit( char * pobjUID, int marksizeunit )
 {
-  if (marksizeunit < 0)
-  {
-    Scierror(999, _("The mark size unit must be greater than %d.\n"),0);
-    return -1;
-  }
-  else
-  {
-    if (sciGetGraphicContext(pobj) != NULL)
+    if (marksizeunit < 0)
+    {
+        Scierror(999, _("The mark size unit must be greater than %d.\n"),0);
+        return -1;
+    }
+    else
     {
-      (sciGetGraphicContext(pobj))->marksizeunit = marksizeunit;
-      return 0;
+        if (sciGetGraphicContext(pobjUID) != NULL)
+        {
+            (sciGetGraphicContext(pobjUID))->marksizeunit = marksizeunit;
+            return 0;
+        }
     }
-  }
 
-  printSetGetErrorMessage("mark_size_unit");
-  return -1;
+    printSetGetErrorMessage("mark_size_unit");
+    return -1;
 }
 
 /**sciSetMarkSizeUnit
@@ -889,34 +918,34 @@ int sciInitMarkSizeUnit( sciPointObj * pobj, int marksizeunit )
  * 1 : points, 2 : tabulated
  */
 int
-sciSetMarkSizeUnit (sciPointObj * pobj, int marksizeunit)
+sciSetMarkSizeUnit (char * pobjUID, int marksizeunit)
 {
 /*
  * Deactivated: the property is set within the MVC regardless of its
  * currently stored value.
  */
 #if 0
-  if ( sciGetMarkSizeUnit( pobj ) == marksizeunit )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( sciGetMarkSizeUnit( pobjUID ) == marksizeunit )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 #endif
 
-  return sciInitMarkSizeUnit( pobj, marksizeunit ) ;
+    return sciInitMarkSizeUnit( pobjUID, marksizeunit ) ;
 }
 
-int sciInitIsLine( sciPointObj * pobj, BOOL isline )
+int sciInitIsLine( char * pobjUID, BOOL isline )
 {
 
-  if (sciGetGraphicContext(pobj) != NULL)
-  {
-    sciGetGraphicContext(pobj)->isline = isline;
-    return 0;
-  }
-
-  printSetGetErrorMessage("line_mode");
-  return -1;
+    if (sciGetGraphicContext(pobjUID) != NULL)
+    {
+        sciGetGraphicContext(pobjUID)->isline = isline;
+        return 0;
+    }
+
+    printSetGetErrorMessage("line_mode");
+    return -1;
 
 }
 
@@ -924,94 +953,102 @@ int sciInitIsLine( sciPointObj * pobj, BOOL isline )
  * Sets the line style existence
  */
 int
-sciSetIsLine (sciPointObj * pobj, BOOL isline)
+sciSetIsLine (char * pobjUID, BOOL isline)
 {
 
-  if ( sciGetIsLine( pobj ) == isline )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitIsLine( pobj, isline ) ;
+    if ( sciGetIsLine( pobjUID ) == isline )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitIsLine( pobjUID, isline ) ;
 }
 /**sciInitPolylineStyle
  * Sets Polyline Style (plot)
  */
-int sciInitPolylineStyle( sciPointObj * pobj, int plot )
+int sciInitPolylineStyle( char * pobjUID, int plot )
 {
-  if (sciGetEntityType(pobj) == SCI_POLYLINE)
-  {
-    pPOLYLINE_FEATURE(pobj)->plot = 4;
-    return 0;
-  }
+    // FIXME
+    abort();
+#if 0
+    if (sciGetEntityType(pobjUID) == SCI_POLYLINE)
+    {
+        pPOLYLINE_FEATURE(pobjUID)->plot = 4;
+        return 0;
+    }
 
-  printSetGetErrorMessage("polyline_style");
-  return -1;
+    printSetGetErrorMessage("polyline_style");
+#endif
+    return -1;
 
 }
 /**sciInitArrowSize
  * Sets Polyline arrow size (to be used with polyline_style=4)
  */
-int sciInitArrowSize( sciPointObj * pobj, double size )
+int sciInitArrowSize( char * pobjUID, double size )
 {
-  if (sciGetEntityType(pobj) == SCI_POLYLINE)
-  {
-    pPOLYLINE_FEATURE(pobj)->arsize_factor = size;
-    return 0;
-  }
+    // FIXME
+    abort();
+#if 0
+    if (sciGetEntityType(pobjUID) == SCI_POLYLINE)
+    {
+        pPOLYLINE_FEATURE(pobjUID)->arsize_factor = size;
+        return 0;
+    }
 
-  printSetGetErrorMessage("arrow_size");
-  return -1;
+    printSetGetErrorMessage("arrow_size");
+#endif
+    return -1;
 
 }
 
 
-int sciInitFontSize( sciPointObj * pobj, double fontSize )
+int sciInitFontSize( char * pobjUID, double fontSize )
 {
-  if (fontSize < 0)
-  {
-    Scierror(999, _("The font size must be greater than %d.\n"),0);
-    return -1;
-  }
-  else
-  {
-    if (sciGetFontContext(pobj) != NULL)
+    if (fontSize < 0)
     {
-      (sciGetFontContext(pobj))->fontSize = fontSize;
-      return 0;
+        Scierror(999, _("The font size must be greater than %d.\n"),0);
+        return -1;
     }
     else
     {
-      printSetGetErrorMessage("font_size");
-      return -1;
+        if (sciGetFontContext(pobjUID) != NULL)
+        {
+            (sciGetFontContext(pobjUID))->fontSize = fontSize;
+            return 0;
+        }
+        else
+        {
+            printSetGetErrorMessage("font_size");
+            return -1;
+        }
     }
-  }
 }
 
 /**sciSetFontSize
  * Sets the font size
  */
-int sciSetFontSize(sciPointObj * pobj, double fontSize)
+int sciSetFontSize(char * pobjUID, double fontSize)
 {
 
-  if (sciGetFontSize( pobj ) == fontSize)
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitFontSize(pobj, fontSize) ;
+    if (sciGetFontSize( pobjUID ) == fontSize)
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitFontSize(pobjUID, fontSize) ;
 
 }
 
-int sciInitFontOrientation( sciPointObj * pobj, double textorientation )
+int sciInitFontOrientation( char * pobjUID, double textorientation )
 {
-  if (sciGetFontContext(pobj) != NULL)
-  {
-    (sciGetFontContext(pobj))->textorientation = textorientation;
-    return 0;
-  }
-  printSetGetErrorMessage("font_angle");
-  return -1;
+    if (sciGetFontContext(pobjUID) != NULL)
+    {
+        (sciGetFontContext(pobjUID))->textorientation = textorientation;
+        return 0;
+    }
+    printSetGetErrorMessage("font_angle");
+    return -1;
 }
 
 
@@ -1020,41 +1057,44 @@ int sciInitFontOrientation( sciPointObj * pobj, double textorientation )
  * Sets the font Orientation
  */
 int
-sciSetFontOrientation (sciPointObj * pobj, double textorientation)
+sciSetFontOrientation (char * pobjUID, double textorientation)
 {
 
-  if ( sciGetFontOrientation( pobj ) == textorientation )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitFontOrientation( pobj, textorientation ) ;
+    if ( sciGetFontOrientation( pobjUID ) == textorientation )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitFontOrientation( pobjUID, textorientation ) ;
 
 }
 
-int sciSetStrings( sciPointObj * pObjDest, const StringMatrix * pStrings )
+int sciSetStrings( char * pobjUIDDest, const StringMatrix * pStrings )
 {
-  switch (sciGetEntityType (pObjDest))
+    // FIXME
+    abort();
+#if 0
+    switch (sciGetEntityType (pobjUIDDest))
     {
     case SCI_TEXT:
-      deleteMatrix( pTEXT_FEATURE (pObjDest)->pStrings ) ;
-      pTEXT_FEATURE (pObjDest)->pStrings = copyStringMatrix( pStrings ) ;
-      if ( pTEXT_FEATURE (pObjDest)->pStrings == NULL )
-      {
-        return -1 ;
-      }
-      break;
+        deleteMatrix( pTEXT_FEATURE (pobjUIDDest)->pStrings ) ;
+        pTEXT_FEATURE (pobjUIDDest)->pStrings = copyStringMatrix( pStrings ) ;
+        if ( pTEXT_FEATURE (pobjUIDDest)->pStrings == NULL )
+        {
+            return -1 ;
+        }
+        break;
     case SCI_LEGEND:
-      deleteMatrix( pLEGEND_FEATURE (pObjDest)->text.pStrings ) ;
-      pLEGEND_FEATURE (pObjDest)->text.pStrings = copyStringMatrix( pStrings ) ;
-      if ( pLEGEND_FEATURE (pObjDest)->text.pStrings == NULL )
-      {
-        return -1 ;
-      }
-      break;
+        deleteMatrix( pLEGEND_FEATURE (pobjUIDDest)->text.pStrings ) ;
+        pLEGEND_FEATURE (pobjUIDDest)->text.pStrings = copyStringMatrix( pStrings ) ;
+        if ( pLEGEND_FEATURE (pobjUIDDest)->text.pStrings == NULL )
+        {
+            return -1 ;
+        }
+        break;
     case SCI_LABEL: /* F.Leray 28.05.04 */
-      return sciSetStrings( pLABEL_FEATURE(pObjDest)->text, pStrings ) ;
-      break;
+        return sciSetStrings( pLABEL_FEATURE(pobjUIDDest)->text, pStrings ) ;
+        break;
     case SCI_UIMENU:
     case SCI_FIGURE:
     case SCI_SUBWIN:
@@ -1068,22 +1108,23 @@ int sciSetStrings( sciPointObj * pObjDest, const StringMatrix * pStrings )
     case SCI_AXES:
     case SCI_AGREG:
     default:
-      printSetGetErrorMessage("text");
-      return -1;
-      break;
+        printSetGetErrorMessage("text");
+        return -1;
+        break;
     }
-  return 0;
+#endif
+    return 0;
 }
 
 /**sciSetText
  * Sets the Text in TEXT, TITLE or LEGEND
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @param char *text[] : the text which has to be put
  * @param int nbRow : the number of row of the text matrix
  * @param int nbCol : the number of col of the text matrix
  * @return  0 if OK, -1 if not
  */
-int sciSetText (sciPointObj * pobj, char ** text, int nbRow, int nbCol)
+int sciSetText (char * pobjUID, char ** text, int nbRow, int nbCol)
 {
     int dimensions[2];
     BOOL status;
@@ -1094,7 +1135,7 @@ int sciSetText (sciPointObj * pobj, char ** text, int nbRow, int nbCol)
     dimensions[0] = nbRow;
     dimensions[1] = nbCol;
 
-    status = setGraphicObjectProperty(pobj->UID, __GO_TEXT_ARRAY_DIMENSIONS__, dimensions, jni_int_vector, 2);
+    status = setGraphicObjectProperty(pobjUID, __GO_TEXT_ARRAY_DIMENSIONS__, dimensions, jni_int_vector, 2);
 
     if (status != TRUE)
     {
@@ -1102,7 +1143,7 @@ int sciSetText (sciPointObj * pobj, char ** text, int nbRow, int nbCol)
         return -1;
     }
 
-    status = setGraphicObjectProperty(pobj->UID, __GO_TEXT_STRINGS__, text, jni_string_vector, dimensions[0]*dimensions[1]);
+    status = setGraphicObjectProperty(pobjUID, __GO_TEXT_STRINGS__, text, jni_string_vector, dimensions[0]*dimensions[1]);
 
     if (status == TRUE)
     {
@@ -1116,35 +1157,38 @@ int sciSetText (sciPointObj * pobj, char ** text, int nbRow, int nbCol)
 }
 
 
-int sciInitFontBackground( sciPointObj * pobj, int colorindex )
+int sciInitFontBackground( char * pobjUID, int colorindex )
 {
-  colorindex = sciSetGoodIndex(pobj,colorindex); /* Adding F.Leray 31.03.04*/
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+    colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_TEXT:
-      (sciGetFontContext(pobj))->backgroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->backgroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_LEGEND:
-      (sciGetFontContext(pobj))->backgroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->backgroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_AXES:
-      (sciGetFontContext(pobj))->backgroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->backgroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_SUBWIN: /* F.Leray 08.04.04 */
-      (sciGetFontContext(pobj))->backgroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->backgroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_FIGURE: /* F.Leray 08.04.04 */
-      (sciGetFontContext(pobj))->backgroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->backgroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_LABEL: /* F.Leray 28.05.04 */
-      (sciGetFontContext(pobj))->backgroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->backgroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_UIMENU:
     case SCI_ARC:
     case SCI_SEGS:
@@ -1155,62 +1199,66 @@ int sciInitFontBackground( sciPointObj * pobj, int colorindex )
     case SCI_SURFACE:
     case SCI_AGREG:
     default:
-      printSetGetErrorMessage("font_background");
-      return -1;
-      break;
+        printSetGetErrorMessage("font_background");
+        return -1;
+        break;
     }
-  return 0;
+#endif
+    return 0;
 }
 
 /**sciSetFontBackground
  * Sets the background color
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @return  int 0 if OK, -1 if not
  */
 int
-sciSetFontBackground (sciPointObj * pobj, int colorindex)
+sciSetFontBackground (char * pobjUID, int colorindex)
 {
-  colorindex = sciSetGoodIndex(pobj,colorindex); /* Adding F.Leray 31.03.04*/
+    colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
 
-  if ( sciGetFontBackground( pobj ) == colorindex )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitFontBackground( pobj, colorindex ) ;
+    if ( sciGetFontBackground( pobjUID ) == colorindex )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitFontBackground( pobjUID, colorindex ) ;
 
 }
 
-int sciInitFontForeground( sciPointObj * pobj, int colorindex )
+int sciInitFontForeground( char * pobjUID, int colorindex )
 {
-  colorindex = sciSetGoodIndex(pobj,colorindex); /* Adding F.Leray 31.03.04*/
+     // FIXME
+    abort();
+#if 0
+   colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
 
-  switch (sciGetEntityType (pobj))
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_TEXT:
-      (sciGetFontContext(pobj))->foregroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->foregroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_LEGEND:
-      (sciGetFontContext(pobj))->foregroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->foregroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_AXES:
-      (sciGetFontContext(pobj))->foregroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->foregroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_SUBWIN: /* F.Leray 08.04.04 */
-      (sciGetFontContext(pobj))->foregroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->foregroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_FIGURE: /* F.Leray 08.04.04 */
-      (sciGetFontContext(pobj))->foregroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->foregroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_LABEL: /* F.Leray 08.04.04 */
-      (sciGetFontContext(pobj))->foregroundcolor =
-       Max (0, Min (colorindex - 1, sciGetNumColors (pobj) + 1));
-      break;
+        (sciGetFontContext(pobjUID))->foregroundcolor =
+            Max (0, Min (colorindex - 1, sciGetNumColors (pobjUID) + 1));
+        break;
     case SCI_UIMENU:
     case SCI_ARC:
     case SCI_SEGS:
@@ -1221,44 +1269,48 @@ int sciInitFontForeground( sciPointObj * pobj, int colorindex )
     case SCI_SURFACE:
     case SCI_AGREG:
     default:
-      printSetGetErrorMessage("font_foreground");
-      return -1;
-      break;
+        printSetGetErrorMessage("font_foreground");
+        return -1;
+        break;
     }
-  return 0;
+#endif
+    return 0;
 }
 
 /**sciSetFontForeground
  * Sets the foreground color
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @return  int 0 if OK, if not
  */
 int
-sciSetFontForeground (sciPointObj * pobj, int colorindex)
+sciSetFontForeground (char * pobjUID, int colorindex)
 {
-  colorindex = sciSetGoodIndex(pobj,colorindex); /* Adding F.Leray 31.03.04*/
+    colorindex = sciSetGoodIndex(pobjUID,colorindex); /* Adding F.Leray 31.03.04*/
 
-  if ( sciGetFontForeground( pobj ) == colorindex )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( sciGetFontForeground( pobjUID ) == colorindex )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 
-  return sciInitFontForeground( pobj, colorindex ) ;
+    return sciInitFontForeground( pobjUID, colorindex ) ;
 }
 
 
-int sciInitFontStyle( sciPointObj * pobj, int iAttributes )
+int sciInitFontStyle( char * pobjUID, int iAttributes )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_TEXT:
     case SCI_LEGEND:
     case SCI_SUBWIN:
     case SCI_FIGURE:
     case SCI_LABEL: /* F.Leray 10.06.04 */
-      (sciGetFontContext(pobj))->fonttype =iAttributes;
-      break;
+        (sciGetFontContext(pobjUID))->fonttype =iAttributes;
+        break;
     case SCI_UIMENU:
     case SCI_ARC:
     case SCI_SEGS:
@@ -1270,77 +1322,85 @@ int sciInitFontStyle( sciPointObj * pobj, int iAttributes )
     case SCI_AXES:
     case SCI_AGREG:
     default:
-      printSetGetErrorMessage("font_style");
-      return -1;
-      break;
+        printSetGetErrorMessage("font_style");
+        return -1;
+        break;
     }
-  return 0;
+#endif
+    return 0;
 }
 
 /**sciSetFontStyle
  * Sets the font style
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @param  int iAttributes (a logical mask with SCI_ATTR_BOLD|SCI_ATTR_ITALIC|SCI_ATTR_UNDERLINE|SCI_ATTR_STRIKEOUT)
  * @return  int 0 if OK, -1 if not
  */
 int
-sciSetFontStyle (sciPointObj * pobj, int iAttributes )
+sciSetFontStyle (char * pobjUID, int iAttributes )
 {
-  if ( sciGetFontStyle( pobj ) == iAttributes )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitFontStyle( pobj, iAttributes ) ;
+    if ( sciGetFontStyle( pobjUID ) == iAttributes )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitFontStyle( pobjUID, iAttributes ) ;
 
 }
 
 
-int sciInitLegendPlace( sciPointObj * pobj, sciLegendPlace place )
+int sciInitLegendPlace( char * pobjUID, sciLegendPlace place )
 {
-  double position[2]={0.0,0.0};
+    // FIXME
+    abort();
+#if 0
+    double position[2]={0.0,0.0};
 
-  if (sciGetEntityType (pobj) == SCI_LEGEND)
-  {
-    pLEGEND_FEATURE (pobj)->place = place;
-    /* calcul de l emplacement relatif du titre
-     * en fonction de la taille de la police
-     * de la fenetre...
-     */
-    return sciInitLegendPos (pobj, position );
-  }
+    if (sciGetEntityType (pobjUID) == SCI_LEGEND)
+    {
+        pLEGEND_FEATURE (pobjUID)->place = place;
+        /* calcul de l emplacement relatif du titre
+         * en fonction de la taille de la police
+         * de la fenetre...
+         */
+        return sciInitLegendPos (pobjUID, position );
+    }
 
-  Scierror(999, _("You are not using a legend object.\n"));
-  return -1;
+    Scierror(999, _("You are not using a legend object.\n"));
+#endif
+    return -1;
 }
 
 /**sciSetLegendPlace
  * Sets the Title Place  with SCI_TITLE_IN_TOP or SCI_TITLE_IN_BOTTOM and calculate the real position in the window
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @return 0 if ok, -1 if not
  */
 int
-sciSetLegendPlace (sciPointObj * pobj, sciLegendPlace place)
+sciSetLegendPlace (char * pobjUID, sciLegendPlace place)
 {
 
 
-  if ( sciGetLegendPlace( pobj ) == place )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitLegendPlace( pobj, place ) ;
+    if ( sciGetLegendPlace( pobjUID ) == place )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitLegendPlace( pobjUID, place ) ;
 
 }
 
-int sciInitLegendPos( sciPointObj * pobj, double position[] )
+int sciInitLegendPos( char * pobjUID, double position[] )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_LEGEND:
-      pLEGEND_FEATURE (pobj)->pos.x = position[0];
-      pLEGEND_FEATURE (pobj)->pos.y = position[1];
-      break;
+        pLEGEND_FEATURE (pobjUID)->pos.x = position[0];
+        pLEGEND_FEATURE (pobjUID)->pos.y = position[1];
+        break;
     case SCI_FIGURE:
     case SCI_SUBWIN:
     case SCI_TEXT:
@@ -1356,102 +1416,107 @@ int sciInitLegendPos( sciPointObj * pobj, double position[] )
     case SCI_LABEL:
     case SCI_UIMENU:
     default:
-      Scierror(999, _("You are not using a legend object.\n"));
-      return -1;
-      break;
+        Scierror(999, _("You are not using a legend object.\n"));
+        return -1;
+        break;
     }
-  return 0;
+#endif
+    return 0;
 }
 
 /**sciSetLegendPos
  * Sets the Legend Position in the window
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @return 0 if ok, -1 if not
  */
 int
-sciSetLegendPos (sciPointObj * pobj, double position[])
+sciSetLegendPos (char * pobjUID, double position[])
 {
-  double position_old[2] ;
-  sciGetLegendPos( pobj ,position_old) ;
-  if ( position[0] ==  position_old[0] && position[1] == position_old[1] )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitLegendPos( pobj, position ) ;
+    double position_old[2] ;
+    sciGetLegendPos( pobjUID ,position_old) ;
+    if ( position[0] ==  position_old[0] && position[1] == position_old[1] )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitLegendPos( pobjUID, position ) ;
 }
 
-int sciInitIsClipping( sciPointObj * pobj, int value )
+int sciInitIsClipping( char * pobjUID, int value )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_SUBWIN:
-      pSUBWIN_FEATURE (pobj)->isclip = value;
-      if(value>0) pSUBWIN_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pSUBWIN_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pSUBWIN_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_ARC:
-      pARC_FEATURE (pobj)->isclip = value;
-      if(value>0) pARC_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pARC_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pARC_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_POLYLINE:
-      pPOLYLINE_FEATURE (pobj)->isclip = value;
-      if(value>0) pPOLYLINE_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pPOLYLINE_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pPOLYLINE_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_RECTANGLE:
-      pRECTANGLE_FEATURE (pobj)->isclip = value;
-      if(value>0) pRECTANGLE_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pRECTANGLE_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pRECTANGLE_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_SEGS:
-      pSEGS_FEATURE (pobj)->isclip = value;
-      if(value>0) pSEGS_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pSEGS_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pSEGS_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_TEXT:
-      pTEXT_FEATURE (pobj)->isclip = value;
-      if(value>0) pTEXT_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pTEXT_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pTEXT_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_AXES:
-      pAXES_FEATURE (pobj)->isclip = value;
-      if(value>0) pAXES_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pAXES_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pAXES_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_SURFACE:
-      pSURFACE_FEATURE (pobj)->isclip = value;
-      if(value>0) pSURFACE_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pSURFACE_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pSURFACE_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_FEC:
-      pFEC_FEATURE (pobj)->isclip = value;
-      if(value>0) pFEC_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pFEC_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pFEC_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_GRAYPLOT:
-      pGRAYPLOT_FEATURE (pobj)->isclip = value;
-      if(value>0) pGRAYPLOT_FEATURE (pobj)->clip_region_set=1;
-      break;
+        pGRAYPLOT_FEATURE (pobjUID)->isclip = value;
+        if(value>0) pGRAYPLOT_FEATURE (pobjUID)->clip_region_set=1;
+        break;
     case SCI_LEGEND:
-                       pLEGEND_FEATURE(pobj)->isclip = value;
-                       if(value>0) { pLEGEND_FEATURE (pobj)->clip_region_set=1;}
-      break;
+        pLEGEND_FEATURE(pobjUID)->isclip = value;
+        if(value>0) { pLEGEND_FEATURE (pobjUID)->clip_region_set=1;}
+        break;
     case SCI_AGREG:
     case SCI_FIGURE:
     case SCI_LABEL: /* F.Leray 28.05.04 */
     case SCI_UIMENU:
     default:
-      printSetGetErrorMessage("clip_state");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("clip_state");
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetIsClipping*/
 int
-sciSetIsClipping( sciPointObj * pobj, int value )
+sciSetIsClipping( char * pobjUID, int value )
 {
 
-  if ( sciGetIsClipping( pobj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitIsClipping( pobj, value ) ;
+    if ( sciGetIsClipping( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitIsClipping( pobjUID, value ) ;
 
 }
 
@@ -1462,72 +1527,79 @@ sciSetIsClipping( sciPointObj * pobj, int value )
  * 29/11/2002
  */
 int
-sciSetClipping (sciPointObj * pobj, double pclip[4] )
+sciSetClipping (char * pobjUID, double pclip[4] )
 {
-  int i;
+    // FIXME
+    abort();
+#if 0
+    int i;
 
-  switch (sciGetEntityType (pobj))
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_SUBWIN:
-      for(i=0;i<4;i++) {pSUBWIN_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pSUBWIN_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_ARC:
-      for(i=0;i<4;i++) {pARC_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pARC_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_POLYLINE:
-      for(i=0;i<4;i++) {pPOLYLINE_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pPOLYLINE_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_RECTANGLE:
-      for(i=0;i<4;i++) {pRECTANGLE_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pRECTANGLE_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_SEGS:
-      for(i=0;i<4;i++) {pSEGS_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pSEGS_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_TEXT:
-      for(i=0;i<4;i++) {pTEXT_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pTEXT_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_AXES:
-      for(i=0;i<4;i++) {pAXES_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pAXES_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_SURFACE:
-      for(i=0;i<4;i++) {pSURFACE_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pSURFACE_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_LEGEND:
-      for(i=0;i<4;i++) {pLEGEND_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pLEGEND_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_FEC:
-      for(i=0;i<4;i++) {pFEC_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pFEC_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_GRAYPLOT:
-      for(i=0;i<4;i++) {pGRAYPLOT_FEATURE (pobj)->clip_region[i] = pclip[i];}
-      break;
+        for(i=0;i<4;i++) {pGRAYPLOT_FEATURE (pobjUID)->clip_region[i] = pclip[i];}
+        break;
     case SCI_LABEL:
-      return sciSetClipping( pLABEL_FEATURE (pobj)->text, pclip ) ;
-      break;
+        return sciSetClipping( pLABEL_FEATURE (pobjUID)->text, pclip ) ;
+        break;
     case SCI_AGREG:
     case SCI_FIGURE:
     case SCI_UIMENU:
     default:
-      printSetGetErrorMessage("clip_box");
-      return -1;
-      break;
+        printSetGetErrorMessage("clip_box");
+        return -1;
+        break;
     }
-  return 0;
+#endif
+    return 0;
 
 }
 
 
-int sciInitAddPlot( sciPointObj * pobj, BOOL value )
+int sciInitAddPlot( char * pobjUID, BOOL value )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      (sciGetGraphicMode (pobj))->addplot = value;
-      break;
+        (sciGetGraphicMode (pobjUID))->addplot = value;
+        break;
     case SCI_SUBWIN:
-      (sciGetGraphicMode (pobj))->addplot = value;
-      /*(sciGetGraphicMode (sciGetParentFigure(pobj)))->addplot = value;*/
-      break;
+        (sciGetGraphicMode (pobjUID))->addplot = value;
+        /*(sciGetGraphicMode (sciGetParentFigure(pobjUID)))->addplot = value;*/
+        break;
     case SCI_TEXT:
     case SCI_LEGEND:
     case SCI_ARC:
@@ -1542,11 +1614,12 @@ int sciInitAddPlot( sciPointObj * pobj, BOOL value )
     case SCI_LABEL: /* F.Leray 28.05.04 */
     case SCI_UIMENU:
     default:
-      printSetGetErrorMessage("auto_clear");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("auto_clear");
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetAddPlot
@@ -1554,31 +1627,34 @@ int sciInitAddPlot( sciPointObj * pobj, BOOL value )
  * If FALSE, plot is cleared before new drawing
  */
 int
-sciSetAddPlot (sciPointObj * pobj, BOOL value)
+sciSetAddPlot (char * pobjUID, BOOL value)
 {
-  if ( sciGetAddPlot( pobj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitAddPlot( pobj, value ) ;
+    if ( sciGetAddPlot( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitAddPlot( pobjUID, value ) ;
 
 }
 
 
-int sciInitAutoScale( sciPointObj * pobj, BOOL value )
+int sciInitAutoScale( char * pobjUID, BOOL value )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      if (pobj == getFigureModel())
-       (sciGetGraphicMode (pobj))->autoscaling = value;
-      else
-       sciSetAutoScale(sciGetFirstTypedSelectedSon(pobj, SCI_SUBWIN),value);
-      break;
+        if (pobjUID == getFigureModel())
+            (sciGetGraphicMode (pobjUID))->autoscaling = value;
+        else
+            sciSetAutoScale(sciGetFirstTypedSelectedSon(pobjUID, SCI_SUBWIN),value);
+        break;
     case SCI_SUBWIN:
-      (sciGetGraphicMode (pobj))->autoscaling = value;
-      break;
+        (sciGetGraphicMode (pobjUID))->autoscaling = value;
+        break;
     case SCI_TEXT:
     case SCI_LEGEND:
     case SCI_ARC:
@@ -1593,42 +1669,45 @@ int sciInitAutoScale( sciPointObj * pobj, BOOL value )
     case SCI_LABEL: /* F.Leray 28.05.04 */
     case SCI_UIMENU:
     default:
-      printSetGetErrorMessage("autos_cale");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("autos_cale");
+        return -1 ;
+        break;
     }
-
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetAutoScale
  * Sets the mode if the plot is in zoom fit mode, or fixed by the user
  */
 int
-sciSetAutoScale (sciPointObj * pobj, BOOL value)
+sciSetAutoScale (char * pobjUID, BOOL value)
 {
 
-  if ( sciGetAutoScale( pobj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitAutoScale( pobj, value ) ;
+    if ( sciGetAutoScale( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitAutoScale( pobjUID, value ) ;
 
 }
 
-int sciInitZooming( sciPointObj * pobj, BOOL value )
+int sciInitZooming( char * pobjUID, BOOL value )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      (sciGetGraphicMode (pobj))->zooming = value;
-      break;
+        (sciGetGraphicMode (pobjUID))->zooming = value;
+        break;
     case SCI_SUBWIN:
-      (sciGetGraphicMode (pobj))->zooming = value;
-      /* the value is inhirated by the parent */
-      sciSetZooming (sciGetParentFigure (pobj), value);
-      break;
+        (sciGetGraphicMode (pobjUID))->zooming = value;
+        /* the value is inhirated by the parent */
+        sciSetZooming (sciGetParentFigure (pobjUID), value);
+        break;
     case SCI_TEXT:
     case SCI_LEGEND:
     case SCI_ARC:
@@ -1643,26 +1722,26 @@ int sciInitZooming( sciPointObj * pobj, BOOL value )
     case SCI_LABEL: /* F.Leray 28.05.04 */
     case SCI_UIMENU:
     default:
-      printSetGetErrorMessage("zoom");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("zoom");
+        return -1 ;
+        break;
     }
-
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetZooming
  * Sets the zooming state of the object. Is it or not zommed right now
  */
 int
-sciSetZooming (sciPointObj * pobj, BOOL value)
+sciSetZooming (char * pobjUID, BOOL value)
 {
-  if ( sciGetZooming( pobj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitZooming( pobj, value ) ;
+    if ( sciGetZooming( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitZooming( pobjUID, value ) ;
 
 }
 
@@ -1677,30 +1756,33 @@ sciSetDefaultValues (void)
 {
 // ???
 #if 0
-  if ((sciInitGraphicContext (sciGetCurrentFigure()) == -1) ||
-      (sciInitGraphicMode (sciGetCurrentFigure()) == -1) ||
-      (sciInitFontContext (sciGetCurrentFigure()) == -1)) /* Adding F.Leray 13.04.04 to have the completed init.*/
-  {
-    Scierror(999, _("Unable to load default values.\n"));
-    return -1 ;
-  }
+    if ((sciInitGraphicContext (sciGetCurrentFigure()) == -1) ||
+        (sciInitGraphicMode (sciGetCurrentFigure()) == -1) ||
+        (sciInitFontContext (sciGetCurrentFigure()) == -1)) /* Adding F.Leray 13.04.04 to have the completed init.*/
+    {
+        Scierror(999, _("Unable to load default values.\n"));
+        return -1 ;
+    }
 #endif
-  return 0;
+    return 0;
 }
 
 
 
-int sciInitXorMode( sciPointObj * pobj, int value )
+int sciInitXorMode( char * pobjUID, int value )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      (sciGetGraphicMode (pobj))->xormode = value;
-      break;
+        (sciGetGraphicMode (pobjUID))->xormode = value;
+        break;
     case SCI_SUBWIN:
-      /* the value is inhirated by the parent */
-      sciSetXorMode (sciGetParentFigure (pobj), value);
-      break;
+        /* the value is inhirated by the parent */
+        sciSetXorMode (sciGetParentFigure (pobjUID), value);
+        break;
     case SCI_TEXT:
     case SCI_LEGEND:
     case SCI_ARC:
@@ -1715,123 +1797,130 @@ int sciInitXorMode( sciPointObj * pobj, int value )
     case SCI_LABEL: /* F.Leray 28.05.04 */
     case SCI_UIMENU:
     default:
-      printSetGetErrorMessage("graphic_mode");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("graphic_mode");
+        return -1 ;
+        break;
     }
-
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetXorMode
  * Sets the xor mode
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @param int value: the value of the xor mode
  * @return
  * @author Djalel ABDEMOUCHE
  * @see sciGetXorMode
  */
 int
-sciSetXorMode (sciPointObj * pobj, int value)
+sciSetXorMode (char * pobjUID, int value)
 {
 
-  if ( sciGetXorMode( pobj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitXorMode( pobj, value ) ;
+    if ( sciGetXorMode( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitXorMode( pobjUID, value ) ;
 
 }
 
-int sciInitVisibility( sciPointObj * pobj, BOOL value )
+int sciInitVisibility( char * pobjUID, BOOL value )
 {
+    // FIXME
+    abort();
+#if 0
 
-  switch (sciGetEntityType (pobj))
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      pFIGURE_FEATURE (pobj)->visible = value;
-      break;
+        pFIGURE_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_SUBWIN:
-      pSUBWIN_FEATURE (pobj)->visible = value;
-      break;
+        pSUBWIN_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_LEGEND:
-      pLEGEND_FEATURE (pobj)->visible = value;
-      break;
+        pLEGEND_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_ARC:
-      pARC_FEATURE (pobj)->visible = value;
-      break;
+        pARC_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_POLYLINE:
-      pPOLYLINE_FEATURE (pobj)->visible = value;
-      break;
+        pPOLYLINE_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_RECTANGLE:
-      pRECTANGLE_FEATURE (pobj)->visible = value;
-      break;
+        pRECTANGLE_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_SURFACE:
-      pSURFACE_FEATURE (pobj)->visible = value;
-      break;
+        pSURFACE_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_SEGS:
-      pSEGS_FEATURE (pobj)->visible = value;
-      break;
+        pSEGS_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_FEC:
-      pFEC_FEATURE (pobj)->visible = value;
-      break;
+        pFEC_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_GRAYPLOT:
-      pGRAYPLOT_FEATURE (pobj)->visible = value;
-      break;
+        pGRAYPLOT_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_TEXT:
-      pTEXT_FEATURE (pobj)->visible = value;
-      break;
+        pTEXT_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_AXES:
-      pAXES_FEATURE (pobj)->visible = value;
-      break;
+        pAXES_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_AGREG:
-      pAGREG_FEATURE (pobj)->visible = value;
-      break;
+        pAGREG_FEATURE (pobjUID)->visible = value;
+        break;
     case SCI_LABEL: /* F.Leray 28.05.04 */
-      return sciInitVisibility( pLABEL_FEATURE(pobj)->text, value ) ;
-      break;
+        return sciInitVisibility( pLABEL_FEATURE(pobjUID)->text, value ) ;
+        break;
     case SCI_UIMENU:
     case SCI_UICONTROL:
     default:
-      return -1 ;
-      break;
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetVisibility*/
 int
-sciSetVisibility (sciPointObj * pobj, BOOL value)
+sciSetVisibility (char * pobjUID, BOOL value)
 {
-  if ( sciGetVisibility( pobj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitVisibility( pobj, value ) ;
+    if ( sciGetVisibility( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitVisibility( pobjUID, value ) ;
 
 }
 
 
-int sciInitResize( sciPointObj * pobj, BOOL value )
+int sciInitResize( char * pobjUID, BOOL value )
 {
+    // FIXME
+    abort();
+#if 0
 
-  switch (sciGetEntityType (pobj))
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      if (isFigureModel(pobj->UID))
-      {
-        pFIGURE_FEATURE(pobj)->pModelData->autoResizeMode = value;
-      }
-      else
-      {
-        sciSetJavaAutoResizeMode(pobj, value);
-      }
-      break;
+        if (isFigureModel(pobjUID))
+        {
+            pFIGURE_FEATURE(pobjUID)->pModelData->autoResizeMode = value;
+        }
+        else
+        {
+            sciSetJavaAutoResizeMode(pobjUID, value);
+        }
+        break;
     case SCI_SUBWIN:
-      sciInitResize(sciGetParentFigure(pobj), value);
-      break;
+        sciInitResize(sciGetParentFigure(pobjUID), value);
+        break;
     case SCI_TEXT:
     case SCI_LEGEND:
     case SCI_ARC:
@@ -1846,113 +1935,122 @@ int sciInitResize( sciPointObj * pobj, BOOL value )
     case SCI_LABEL: /* F.Leray 28.05.04 */
     case SCI_UIMENU:
     default:
-      printSetGetErrorMessage("auto_resize");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("auto_resize");
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetResize
  * Tunrs ON or OFF the autoresizing mode (when the window is resized by user)
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @param BOOL value: the value of the switch
  */
 int
-sciSetResize (sciPointObj * pobj, BOOL value)
+sciSetResize (char * pobjUID, BOOL value)
 {
 
-  if ( sciGetResize( pobj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitResize( pobj, value ) ;
+    if ( sciGetResize( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitResize( pobjUID, value ) ;
 
 }
 
 
 
-int sciInitName(sciPointObj * pobj, char * newName)
+int sciInitName(char * pobjUID, char * newName)
 {
-  switch (sciGetEntityType (pobj))
-  {
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
+    {
     case SCI_FIGURE:
     {
-      int newNameLength;
+        int newNameLength;
 
-                       /* first case newName is NULL */
-                       if (newName == NULL)
-                       {
-                               /* Just set an empty title for the physical window if needed */
-                               if (!isFigureModel(pobj->UID))
-                               {
-                                       sciSetJavaTitle(pobj, "");
-                               }
+        /* first case newName is NULL */
+        if (newName == NULL)
+        {
+            /* Just set an empty title for the physical window if needed */
+            if (!isFigureModel(pobjUID))
+            {
+                sciSetJavaTitle(pobjUID, "");
+            }
 
-                               return 0;
-                       }
+            return 0;
+        }
 
-                       /* newName is a valid string */
-                       newNameLength = (int) strlen(newName);
+        /* newName is a valid string */
+        newNameLength = (int) strlen(newName);
 
-      /* Reallocate name */
-      pFIGURE_FEATURE(pobj)->name = MALLOC( (newNameLength + 1) * sizeof(char) );
+        /* Reallocate name */
+        pFIGURE_FEATURE(pobjUID)->name = MALLOC( (newNameLength + 1) * sizeof(char) );
 
-                       /* copy the string */
-      strcpy(pFIGURE_FEATURE(pobj)->name, newName) ;
+        /* copy the string */
+        strcpy(pFIGURE_FEATURE(pobjUID)->name, newName) ;
 
-                       /* Update the name of the physical window if one exists */
-      if (!isFigureModel(pobj->UID))
-      {
-       /* In this case, we need to send the name to the physical window */
-        if ( checkPercent(newName) == 0 )
-        {
-               /* no %d, set the java title directly */
-               sciSetJavaTitle(pobj, pFIGURE_FEATURE(pobj)->name);
-        }
-        else
+        /* Update the name of the physical window if one exists */
+        if (!isFigureModel(pobjUID))
         {
-          /* a %d inside */
-          /* get the number digits of the window number */
-          int figureNumber = sciGetNum( pobj ) ;
-          int nbDigits = GET_NB_DIGITS( figureNumber ) ;
-          int realTitleLength = newNameLength + nbDigits - 2 ; /* -2 for the %d which is replaced */
-          char * realTitle = MALLOC( (realTitleLength + 1) * sizeof(char) ) ;
-          if ( realTitle == NULL )
-          {
-            Scierror(999, _("%s: No more memory.\n"),"sciSetName");
-            return -1 ;
-          }
-          sprintf( realTitle, newName, figureNumber ) ;
-          sciSetJavaTitle(pobj, realTitle);
-          FREE(realTitle) ;
-        }
+            /* In this case, we need to send the name to the physical window */
+            if ( checkPercent(newName) == 0 )
+            {
+                /* no %d, set the java title directly */
+                sciSetJavaTitle(pobjUID, pFIGURE_FEATURE(pobjUID)->name);
+            }
+            else
+            {
+                /* a %d inside */
+                /* get the number digits of the window number */
+                int figureNumber = sciGetNum( pobjUID ) ;
+                int nbDigits = GET_NB_DIGITS( figureNumber ) ;
+                int realTitleLength = newNameLength + nbDigits - 2 ; /* -2 for the %d which is replaced */
+                char * realTitle = MALLOC( (realTitleLength + 1) * sizeof(char) ) ;
+                if ( realTitle == NULL )
+                {
+                    Scierror(999, _("%s: No more memory.\n"),"sciSetName");
+                    return -1 ;
+                }
+                sprintf( realTitle, newName, figureNumber ) ;
+                sciSetJavaTitle(pobjUID, realTitle);
+                FREE(realTitle) ;
+            }
 
 
-      }
+        }
 
-      return 0 ;
+        return 0 ;
     }
     default:
-      printSetGetErrorMessage("figure_name");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("figure_name");
+        return -1 ;
+        break;
     }
+#endif
+        return -1;
 }
 
 /**sciSetName
  * Sets the name of the Figure
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @param char newName: a pointer to the string contening name
  * @return
  */
 int
-sciSetName(sciPointObj * pobj, char * newName)
+sciSetName(char * pobjUID, char * newName)
 {
-  if (   newName != NULL
-      && sciGetName(pobj) != NULL
-      && strcmp(sciGetName(pobj), newName) == 0)
+    // FIXME
+    abort();
+#if 0
+        if (   newName != NULL
+           && sciGetName(pobjUID) != NULL
+           && strcmp(sciGetName(pobjUID), newName) == 0)
        {
                // nothing to do
                return 1;
@@ -1960,180 +2058,198 @@ sciSetName(sciPointObj * pobj, char * newName)
 
        /* Check that the string contains at most one %d character */
        if (checkPercent(newName) < 0)
-  {
-       Scierror(999, _("Figure name may not contains any %% character, except a single %%d.\n")) ;
-       return -1 ;
-  }
+    {
+        Scierror(999, _("Figure name may not contains any %% character, except a single %%d.\n")) ;
+        return -1 ;
+    }
 
        /* Free the current name if needed */
-       if (sciGetName(pobj) != NULL)
+       if (sciGetName(pobjUID) != NULL)
        {
-               FREE(pFIGURE_FEATURE(pobj)->name);
-               pFIGURE_FEATURE(pobj)->name = NULL;
+               FREE(pFIGURE_FEATURE(pobjUID)->name);
+               pFIGURE_FEATURE(pobjUID)->name = NULL;
        }
 
-       return sciInitName(pobj, newName);
+       return sciInitName(pobjUID, newName);
+#endif
+    return 1;
 }
 
-int sciInitNum( sciPointObj * pobj, int value )
+int sciInitNum( char * pobjUID, int value )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      pFIGURE_FEATURE(pobj)->number = value;
-      break;
+        pFIGURE_FEATURE(pobjUID)->number = value;
+        break;
     default:
-      printSetGetErrorMessage("figure_id");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("figure_id");
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetNum
  * Sets the number of the Figure.
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @param int value: the value of the number of the windows
  */
 int
-sciSetNum (sciPointObj * pobj, int value )
+sciSetNum (char * pobjUID, int value )
 {
 
-  if ( sciGetNum(pobj) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitNum( pobj, value ) ;
+    if ( sciGetNum(pobjUID) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitNum( pobjUID, value ) ;
 
 }
 
-int sciInitDimension( sciPointObj * pobj, int newWidth, int newHeight )
+int sciInitDimension( char * pobjUID, int newWidth, int newHeight )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      if ( isFigureModel(pobj->UID) )
-      {
-        pFIGURE_FEATURE(pobj)->pModelData->figureWidth  = newWidth ;
-        pFIGURE_FEATURE(pobj)->pModelData->figureHeight = newHeight;
-      }
-      else
-      {
-        int size[2] = {newWidth, newHeight} ;
-        return sciSetJavaFigureSize(pobj, size) ;
-      }
-      break;
+        if ( isFigureModel(pobjUID) )
+        {
+            pFIGURE_FEATURE(pobjUID)->pModelData->figureWidth  = newWidth ;
+            pFIGURE_FEATURE(pobjUID)->pModelData->figureHeight = newHeight;
+        }
+        else
+        {
+            int size[2] = {newWidth, newHeight} ;
+            return sciSetJavaFigureSize(pobjUID, size) ;
+        }
+        break;
     default:
-      printSetGetErrorMessage("size");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("size");
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 
 /**sciSetDim
  * Sets the dimension of the Figure or Subwin
- * @param sciPointObj * pobj: the pointer to the entity
+ * @param char * pobjUID: the pointer to the entity
  * @param int *pwidth: the width of the window dimension
  * @param int *pheight: the height of the window dimension
  * @return one of the EResizeStatus values.
  */
-int sciSetDimension( sciPointObj * pobj, int newWidth, int newHeight )
+int sciSetDimension( char * pobjUID, int newWidth, int newHeight )
 {
 
-  int width ;
-  int height ;
-  sciGetDim( pobj, &width, &height ) ;
-  if ( width == newWidth && height == newHeight )
-  {
-    return 1 ;
-  }
-  return sciInitDimension( pobj, newWidth, newHeight ) ;
+    int width ;
+    int height ;
+    sciGetDim( pobjUID, &width, &height ) ;
+    if ( width == newWidth && height == newHeight )
+    {
+        return 1 ;
+    }
+    return sciInitDimension( pobjUID, newWidth, newHeight ) ;
 
 }
 
-int sciInitWindowDim( sciPointObj * pobj, int newWidth, int newHeight )
+int sciInitWindowDim( char * pobjUID, int newWidth, int newHeight )
 {
-  switch (sciGetEntityType (pobj))
-  {
-  case SCI_FIGURE:
-    if ( pobj == getFigureModel() )
-    {
-      pFIGURE_FEATURE(pobj)->pModelData->windowWidth  = newWidth ;
-      pFIGURE_FEATURE(pobj)->pModelData->windowHeight = newHeight;
-    }
-    else
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
-      int size[2] = {newWidth, newHeight} ;
-      sciSetJavaWindowSize(pobj, size) ;
-      //Check the new size
-      sciGetJavaWindowSize(pobj, size);
-      if(size[0]!=newWidth || size[1]!=newHeight)
-      {
-        sciprint(_("WARNING : The size of the figure may not be as wide as you want.\n"));
-      }
+    case SCI_FIGURE:
+        if ( pobjUID == getFigureModel() )
+        {
+            pFIGURE_FEATURE(pobjUID)->pModelData->windowWidth  = newWidth ;
+            pFIGURE_FEATURE(pobjUID)->pModelData->windowHeight = newHeight;
+        }
+        else
+        {
+            int size[2] = {newWidth, newHeight} ;
+            sciSetJavaWindowSize(pobjUID, size) ;
+            //Check the new size
+            sciGetJavaWindowSize(pobjUID, size);
+            if(size[0]!=newWidth || size[1]!=newHeight)
+            {
+                sciprint(_("WARNING : The size of the figure may not be as wide as you want.\n"));
+            }
+        }
+        break;
+    default:
+        printSetGetErrorMessage("figure_size");
+        return -1 ;
+        break;
     }
-    break;
-  default:
-    printSetGetErrorMessage("figure_size");
-    return -1 ;
-    break;
-  }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
-int sciSetWindowDim( sciPointObj * pobj, int newWidth, int newHeight )
+int sciSetWindowDim( char * pobjUID, int newWidth, int newHeight )
 {
-  if ( sciGetWindowWidth(pobj) == newWidth && sciGetWindowHeight(pobj) == newHeight )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitWindowDim(pobj, newWidth, newHeight ) ;
+    if ( sciGetWindowWidth(pobjUID) == newWidth && sciGetWindowHeight(pobjUID) == newHeight )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitWindowDim(pobjUID, newWidth, newHeight ) ;
 }
 
-int sciInitScreenPosition( sciPointObj * pobj, int pposx, int pposy )
+int sciInitScreenPosition( char * pobjUID, int pposx, int pposy )
 {
+    // FIXME
+    abort();
+#if 0
 
-  switch (sciGetEntityType (pobj))
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_FIGURE:
-      if ( pobj == getFigureModel() )
-      {
-        pFIGURE_FEATURE(pobj)->pModelData->windowPosition[0] = pposx ;
-        pFIGURE_FEATURE(pobj)->pModelData->windowPosition[1] = pposy ;
-      }
-      else
-      {
-        int pos[2] = {pposx, pposy} ;
-        sciSetJavaWindowPosition(pobj, pos) ;
-      }
-      return 0;
+        if ( pobjUID == getFigureModel() )
+        {
+            pFIGURE_FEATURE(pobjUID)->pModelData->windowPosition[0] = pposx ;
+            pFIGURE_FEATURE(pobjUID)->pModelData->windowPosition[1] = pposy ;
+        }
+        else
+        {
+            int pos[2] = {pposx, pposy} ;
+            sciSetJavaWindowPosition(pobjUID, pos) ;
+        }
+        return 0;
     default:
-      printSetGetErrorMessage("figure_position");
-      return -1;
-      break;
+        printSetGetErrorMessage("figure_position");
+        return -1;
+        break;
     }
-  return 0;
+#endif
+    return 0;
 }
 
 /**sciSetScreenPosition
  * Sets the position of the FIGURE (the window) in root.
  */
 int
-sciSetScreenPosition(sciPointObj * pobj, int pposx, int pposy)
+sciSetScreenPosition(char * pobjUID, int pposx, int pposy)
 {
-  int posX ;
-  int posY ;
-  sciGetScreenPosition( pobj, &posX, &posY ) ;
-  if ( posX == pposx && posY == pposy )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitScreenPosition( pobj, pposx, pposy ) ;
+    int posX ;
+    int posY ;
+    sciGetScreenPosition( pobjUID, &posX, &posY ) ;
+    if ( posX == pposx && posY == pposy )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitScreenPosition( pobjUID, pposx, pposy ) ;
 
 }
 
@@ -2142,54 +2258,61 @@ sciSetScreenPosition(sciPointObj * pobj, int pposx, int pposy)
 /* sciSelectFirstSubwin                                                              */
 /* select under the first window found under the current figure                      */
 /*--------------------------------------------------------------------------*/
-void sciSelectFirstSubwin( sciPointObj * parentFigure )
+void sciSelectFirstSubwin( char * parentFigure )
 {
-  sciSons * figureSons = sciGetSons ( parentFigure ) ;
-  if ( figureSons != (sciSons *) NULL )
-  {
-    /* look for the first subwindow */
-    while (   (figureSons->pnext != (sciSons *) NULL)
-           && (sciGetEntityType (figureSons->pointobj) != SCI_SUBWIN))
+    // FIXME
+    abort();
+#if 0
+        sciSons * figureSons = sciGetSons ( parentFigure ) ;
+    if ( figureSons != (sciSons *) NULL )
     {
-      figureSons = figureSons->pnext;
-    }
+        /* look for the first subwindow */
+        while (   (figureSons->pnext != (sciSons *) NULL)
+                  && (sciGetEntityType (figureSons->pointobj) != SCI_SUBWIN))
+        {
+            figureSons = figureSons->pnext;
+        }
 
-    if( sciGetEntityType (figureSons->pointobj) == SCI_SUBWIN )
-    {
-      /* we found another valid subwindow */
-      sciSetSelectedSubWin (figureSons->pointobj);
-    }
-    else
-    {
-      sciSetSelectedSubWin(NULL);
+        if( sciGetEntityType (figureSons->pointobj) == SCI_SUBWIN )
+        {
+            /* we found another valid subwindow */
+            sciSetSelectedSubWin (figureSons->pointobj);
+        }
+        else
+        {
+            sciSetSelectedSubWin(NULL);
+        }
     }
-  }
+#endif
 }
 
 
-int sciInitSelectedSubWin( sciPointObj * psubwinobj )
+int sciInitSelectedSubWin( char * psubwinobj )
 {
-  sciSubWindow * ppSubWin = pSUBWIN_FEATURE ( psubwinobj ) ;
-
-  sciInitSelectedObject( psubwinobj ) ;
+    // FIXME
+    abort();
+#if 0
+        sciSubWindow * ppSubWin = pSUBWIN_FEATURE ( psubwinobj ) ;
 
-  return 0 ;
+    sciInitSelectedObject( psubwinobj ) ;
+#endif
+    return 0 ;
 }
 
 /**sciSetSelectedSubWin
  * Determines wich SubWin is selected or not. WARNING TO BE DEFINED.
  * It has been adapted to the MVC. Its should be implemented entirely
  * within the MVC (as the setGraphicObjectRelationship function).
- * @param sciPointObj * psubwinobj: the pointer to the entity sub window
+ * @param char * psubwinobj: the pointer to the entity sub window
  * @return 1 if OK or -1 if NOT OK
  */
 int
-sciSetSelectedSubWin (sciPointObj * psubwinobj)
+sciSetSelectedSubWin (char * psubwinobjUID)
 {
     char* type;
     char* parent;
 
-    getGraphicObjectProperty(psubwinobj->UID, __GO_TYPE__, jni_string, &type);
+    getGraphicObjectProperty(psubwinobjUID, __GO_TYPE__, jni_string, &type);
 
     /* Check that the object is an AXES */
     if (strcmp(type, __GO_AXES__) != 0)
@@ -2198,9 +2321,9 @@ sciSetSelectedSubWin (sciPointObj * psubwinobj)
         return -1;
     }
 
-    getGraphicObjectProperty(psubwinobj->UID, __GO_PARENT__, jni_string, &parent);
+    getGraphicObjectProperty(psubwinobjUID, __GO_PARENT__, jni_string, &parent);
 
-    setGraphicObjectProperty(parent, __GO_SELECTED_CHILD__, psubwinobj->UID, jni_string, 1);
+    setGraphicObjectProperty(parent, __GO_SELECTED_CHILD__, psubwinobjUID, jni_string, 1);
 
     /* To be deleted */
 #if 0
@@ -2224,24 +2347,28 @@ sciSetSelectedSubWin (sciPointObj * psubwinobj)
 }
 
 /*-------------------------------------------------------------------------------*/
-int sciInitSelectedObject( sciPointObj * pObj )
+int sciInitSelectedObject( char * pobjUID )
 {
-  sciAddUniqueSelectedSon(sciGetParent(pObj), pObj ) ;
-  return 0 ;
+    sciAddUniqueSelectedSon(sciGetParent(pobjUID), pobjUID ) ;
+    return 0 ;
 }
 /*-------------------------------------------------------------------------------*/
 
 /**sciSetOriginalSubWin
  * DO NOT USE !!!
- * @param sciPointObj * pfigure, the parent figure,
- * @param sciPointObj * psubwin: the pointer to the entity subwindow
+ * @param char * pfigure, the parent figure,
+ * @param char * psubwin: the pointer to the entity subwindow
  * @return 0 if OK -1 if not
  */
 int
-sciSetOriginalSubWin (sciPointObj * pfigure, sciPointObj * psubwin)
+sciSetOriginalSubWin (char * pfigure, char * psubwin)
 {
-  pFIGURE_FEATURE(pfigure)->originalsubwin0011 = psubwin;
-  return 0;
+    // FIXME
+    abort();
+#if 0
+        pFIGURE_FEATURE(pfigure)->originalsubwin0011 = psubwin;
+#endif
+    return 0;
 }
 
 /**sciSetPoint
@@ -2249,426 +2376,426 @@ sciSetOriginalSubWin (sciPointObj * pfigure, sciPointObj * psubwin)
  */
 /** MAJ pour le 3D DJ.Abdemouche 2003**/
 int
-sciSetPoint(sciPointObj * pthis, double *tab, int *numrow, int *numcol)
-{
-  char* type;
-  int i,n1,k,k1,k2;
-  double * pvx  = NULL ;
-  double * pvy  = NULL ;
-  double * pvz  = NULL ;
-  double * pvfx = NULL ;
-  double * pvfy = NULL ;
-  double * pvfz = NULL ;
-  int * pstyle = NULL;
-
-  getGraphicObjectProperty(pthis->UID, __GO_TYPE__, jni_string, &type);
-
-  /*
-   * switch over sciGetEntityType replaced by object type string comparisons
-   * Still required as we have no better way to do this for the moment
-   */
-  if (strcmp(type, __GO_POLYLINE__) == 0)
-  {
-      BOOL result;
-      int numElementsArray[2];
-      int zCoordinatesSet;
-
-      if ( (*numcol != 3) && (*numcol != 2) && (*numcol != 0) )
-      {
-         Scierror(999, _("Number of columns must be %d (%d if %s coordinate).\n"),2,3,"z");
-         return -1;
-      }
-
-      /*
-       * The coordinates array is re-allocated (if required) within the data model, testing whether
-       * the new number of points is different in order to free/re-allocate is not needed anymore.
-       * The 0-element array case is managed by the data model as well.
-       */
-
-      if (*numcol == 0)
-      {
-          n1 = 0;
-      }
-      else
-      {
-          n1 = *numrow;
-      }
-
-      /* The first element must be equal to 1 for a Polyline, the second is the polyline's number of vertices */
-      numElementsArray[0] = 1;
-      numElementsArray[1] = n1;
-
-      /* Resizes the data coordinates array if required */
-      result = setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
-
-      /*
-       * For now, the FALSE return value corresponds to a failed memory allocation,
-       * which does not allow to discriminate between the failed allocation and non-existing
-       * property conditions.
-       */
-      if (result == FALSE)
-      {
-         Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
-          return -1;
-      }
-
-      if ( *numcol > 0 )
-      {
-          setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_X__, tab, jni_double_vector, n1);
-          setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_Y__, &tab[n1], jni_double_vector, n1);
-
-          if (*numcol == 3)
-          {
-              setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_Z__, &tab[2*n1], jni_double_vector, n1);
-              zCoordinatesSet = 1;
-          }
-          else
-          {
-              zCoordinatesSet = 0;
-          }
-
-          /* Required for now to indicate that the z coordinates have been set or not */
-          setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zCoordinatesSet, jni_int, 1);
-      }
-
-      return 0;
-  }
-  else if (strcmp(type, __GO_RECTANGLE__) == 0)
-  {
-      double* currentUpperLeftPoint;
-      double upperLeftPoint[3];
-      int widthIndex = 2;
-      int size = *numrow * *numcol;
-
-      if ( size != 5 && size != 4 )
-      {
-          Scierror(999, _("Number of elements must be %d (%d if %s coordinate).\n"),4,5,"z");
-          return -1;
-      }
-
-      upperLeftPoint[0] = tab[0];
-      upperLeftPoint[1] = tab[1];
-
-      if ( size == 5 )
-      {
-          upperLeftPoint[2] = tab[2];
-          widthIndex = 3;
-      }
-      else
-      {
-          /*
-           * Needed in order to set the z coordinate if size == 4
-           * Being able to set only the point's x and y coordinates values would avoid doing this.
-           */
-          getGraphicObjectProperty(pthis->UID, __GO_UPPER_LEFT_POINT__, jni_double_vector, &currentUpperLeftPoint);
-          upperLeftPoint[2] = currentUpperLeftPoint[2];
-      }
-
-      setGraphicObjectProperty(pthis->UID, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
-
-      /* check that the height and width are positive */
-      if ( tab[widthIndex] < 0.0 || tab[widthIndex + 1] < 0.0 )
-      {
-        Scierror(999,"Width and height must be positive.\n") ;
-        return -1 ;
-      }
-
-      setGraphicObjectProperty(pthis->UID, __GO_WIDTH__, &tab[widthIndex], jni_double, 1);
-      setGraphicObjectProperty(pthis->UID, __GO_HEIGHT__, &tab[widthIndex + 1], jni_double, 1);
-
-      return 0;
-  }
-  else if (strcmp(type, __GO_ARC__) == 0)
-  {
-      double startAngle;
-      double endAngle;
-      double upperLeftPoint[3];
-      double width;
-      double height;
-      double* currentUpperLeftPoint;
-      int size;
-
-      size = *numrow * *numcol;
-
-      if ((size != 7) && (size != 6))
-      {
-          Scierror(999, _("Number of elements must be %d (%d if z coordinate )\n"),6,7);
-          return -1;
-      }
-
-      upperLeftPoint[0] = tab[0];
-      upperLeftPoint[1] = tab[1];
-
-      /*
-       * Setting the data has been made consistent with how it is done for the Rectangle:
-       * it takes into account the size of the input array instead of the parent Axes'
-       * view property. Using the latter led to incorrectly set values when size and view
-       * were not corresponding (for example when size==7, and view==2d).
-       */
-      if (size == 7)
-      {
-          upperLeftPoint[2] = tab[2];
-          width = tab[3];
-          height = tab[4];
-          startAngle = DEG2RAD(tab[5]);
-          endAngle = DEG2RAD(tab[6]);
-      }
-      else
-      {
-          /* Needed in order to set the z coordinate if size == 6 */
-          getGraphicObjectProperty(pthis->UID, __GO_UPPER_LEFT_POINT__, jni_double_vector, &currentUpperLeftPoint);
-
-          upperLeftPoint[2] = currentUpperLeftPoint[2];
-          width = tab[2];
-          height = tab[3];
-          startAngle = DEG2RAD(tab[4]);
-          endAngle = DEG2RAD(tab[5]);
-      }
-
-      setGraphicObjectProperty(pthis->UID, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
-
-      setGraphicObjectProperty(pthis->UID, __GO_WIDTH__, &width, jni_double, 1);
-      setGraphicObjectProperty(pthis->UID, __GO_HEIGHT__, &height, jni_double, 1);
-
-      setGraphicObjectProperty(pthis->UID, __GO_START_ANGLE__, &startAngle, jni_double, 1);
-      setGraphicObjectProperty(pthis->UID, __GO_END_ANGLE__, &endAngle, jni_double, 1);
-
-      return 0;
-  }
-  else if (strcmp(type, __GO_TEXT__) == 0)
-  {
-      char* parentAxes;
-      double position[3];
-      int iView = 0;
-      int* piView = &iView;
-
-      if ((*numrow * *numcol != 2)&&(*numrow * *numcol != 3))
-      {
-          Scierror(999, _("Number of elements must be %d (%d if %s coordinate).\n"),2,3,"z");
-          return -1;
-      }
-
-      getGraphicObjectProperty(pthis->UID, __GO_PARENT_AXES__, jni_string, &parentAxes);
-      getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
-
-      position[0] = tab[0];
-      position[1] = tab[1];
-
-      if (iView)
-      {
-          position[2] = tab[2];
-      }
-      else
-      {
-          /*
-           * Required as the position has 3 coordinates, hence the z-coordinate
-           * is set to its current value, which must be retrieved beforehand.
-           * Avoiding doing this would require being able to set only the x and y
-           * coordinates if required.
-           */
-          double* currentPosition;
-          getGraphicObjectProperty(pthis->UID, __GO_POSITION__, jni_double_vector, &currentPosition);
-          position[2] = currentPosition[2];
-      }
-
-      setGraphicObjectProperty(pthis->UID, __GO_POSITION__, position, jni_double_vector, 3);
-
-      return 0;
-  }
-  else if (strcmp(type, __GO_SEGS__) == 0)
-  {
-      int numArrows;
-      double* arrowPoints = NULL;
-
-      if ((*numcol != 3)&&(*numcol != 2))
-      {
-          Scierror(999, _("Number of columns must be %d (%d if %s coordinate).\n"),2,3,"z");
-          return -1;
-      }
-
-      if (*numrow % 2 != 0)
-      {
-          Scierror(999, _("Number of rows must be a multiple of 2.\n"));
-          return -1;
-      }
-
-
-      numArrows = *numrow/2;
-
-      arrowPoints = (double*) MALLOC(3*numArrows*sizeof(double));
-
-      if (arrowPoints == NULL)
-      {
-          Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
-          return -1;
-      }
-
-      /*
-       * Interlacing ought to be done in the MVC's coordinates
-       * set function to avoid the additional code below.
-       */
-      for (i = 0; i < numArrows; i++)
-      {
-          arrowPoints[3*i] = tab[2*i];
-          arrowPoints[3*i+1] = tab[2*numArrows+2*i];
-
-          if (*numcol == 3)
-          {
-              arrowPoints[3*i+2] = tab[4*numArrows+2*i];
-          }
-          else
-          {
-              arrowPoints[3*i+2] = 0.0;
-          }
-      }
-
-      setGraphicObjectProperty(pthis->UID, __GO_NUMBER_ARROWS__, &numArrows, jni_int, 1);
-
-      setGraphicObjectProperty(pthis->UID, __GO_BASE__, arrowPoints, jni_double_vector, 3*numArrows);
-
-      for (i = 0; i < numArrows; i++)
-      {
-          arrowPoints[3*i] = tab[2*i+1];
-          arrowPoints[3*i+1] = tab[2*numArrows+2*i+1];
-
-          if (*numcol == 3)
-          {
-              arrowPoints[3*i+2] = tab[4*numArrows+2*i+1];
-          }
-          else
-          {
-              arrowPoints[3*i+2] = 0.0;
-          }
-      }
-
-      setGraphicObjectProperty(pthis->UID, __GO_DIRECTION__, arrowPoints, jni_double_vector, 3*numArrows);
-
-      FREE(arrowPoints);
-
-      return 0;
-  }
-  /* DJ.A 2003 */
-  /* SCI_SURFACE has been replaced by the MVC's FAC3D and PLOT3D */
-  else if (strcmp(type, __GO_FAC3D__) == 0)
-  {
-      Scierror(999, _("Unhandled data field\n"));
-      return -1;
-  }
-  else if (strcmp(type, __GO_PLOT3D__) == 0)
-  {
-      Scierror(999, _("Unhandled data field\n"));
-      return -1;
-  }
-  else if (strcmp(type, __GO_MATPLOT__) == 0)
-  {
-      int nx;
-      int ny;
-      int gridSize[4];
-      int result;
-
-      ny = *numrow;
-      nx = *numcol;
-
-      /*
-       * The number of points along each dimension is equal to the z data matrix's
-       * corresponding dimension plus 1
-       */
-      gridSize[0] = nx + 1;
-      gridSize[1] = 1;
-      gridSize[2] = ny + 1;
-      gridSize[3] = 1;
-
-      result = setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
-
-      if (result == FALSE)
-      {
-          Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
-          return -1;
-      }
-
-      setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_Z__, tab, jni_double_vector, nx*ny);
-  }
-  else if (strcmp(type, __GO_FEC__) == 0)
-  {
-      BOOL result;
-      int Nnode;
-      if (*numcol != 3)
-      {
-          Scierror(999, _("Number of columns must be %d.\n"),3);
-          return -1;
-      }
-
-      Nnode = *numrow;
-
-      /* Resizes the data coordinates array if required */
-      result = setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_NUM_VERTICES__, &Nnode, jni_int, 1);
-
-      if (result == FALSE)
-      {
-          Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
-          return -1;
-      }
-
-      setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_X__, tab, jni_double_vector, Nnode);
-      setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_Y__, &tab[Nnode], jni_double_vector, Nnode);
-      setGraphicObjectProperty(pthis->UID, __GO_DATA_MODEL_VALUES__, &tab[2*Nnode], jni_double_vector, Nnode);
-  }
-  else if (strcmp(type, __GO_FIGURE__) == 0)
-  {
-      printSetGetErrorMessage("data");
-      return -1;
-  }
-  else if (strcmp(type, __GO_AXES__) == 0)
-  {
-      printSetGetErrorMessage("data");
-      return -1;
-  }
-  else if (strcmp(type, __GO_LEGEND__) == 0)
-  {
-      printSetGetErrorMessage("data");
-      return -1;
-  }
-  else if (strcmp(type, __GO_AXIS__) == 0)
-  {
-      printSetGetErrorMessage("data");
-      return -1;
-  }
-  else if (strcmp(type, __GO_COMPOUND__) == 0)
-  {
-      printSetGetErrorMessage("data");
-      return -1;
-  }
-  /* F.Leray 28.05.04 */
-  else if (strcmp(type, __GO_LABEL__) == 0)
-  {
-      printSetGetErrorMessage("data");
-      return -1;
-  }
-  /*
-   * Deactivated for now
-   * Same condition as the default one
-   */
-#if 0
-    case SCI_UIMENU:
-#endif
-  else
-  {
-      printSetGetErrorMessage("data");
-      return -1;
-  }
-
-  return 0;
-}
-
-int sciInitdrawmode( BOOL mode )
+sciSetPoint(char * pthis, double *tab, int *numrow, int *numcol)
 {
+    char* type;
+    int i,n1,k,k1,k2;
+    double * pvx  = NULL ;
+    double * pvy  = NULL ;
+    double * pvz  = NULL ;
+    double * pvfx = NULL ;
+    double * pvfy = NULL ;
+    double * pvfz = NULL ;
+    int * pstyle = NULL;
+
+    getGraphicObjectProperty(pthis, __GO_TYPE__, jni_string, &type);
+
+    /*
+     * switch over sciGetEntityType replaced by object type string comparisons
+     * Still required as we have no better way to do this for the moment
+     */
+    if (strcmp(type, __GO_POLYLINE__) == 0)
+    {
+        BOOL result;
+        int numElementsArray[2];
+        int zCoordinatesSet;
+
+        if ( (*numcol != 3) && (*numcol != 2) && (*numcol != 0) )
+        {
+            Scierror(999, _("Number of columns must be %d (%d if %s coordinate).\n"),2,3,"z");
+            return -1;
+        }
+
+        /*
+         * The coordinates array is re-allocated (if required) within the data model, testing whether
+         * the new number of points is different in order to free/re-allocate is not needed anymore.
+         * The 0-element array case is managed by the data model as well.
+         */
+
+        if (*numcol == 0)
+        {
+            n1 = 0;
+        }
+        else
+        {
+            n1 = *numrow;
+        }
+
+        /* The first element must be equal to 1 for a Polyline, the second is the polyline's number of vertices */
+        numElementsArray[0] = 1;
+        numElementsArray[1] = n1;
+
+        /* Resizes the data coordinates array if required */
+        result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
+
+        /*
+         * For now, the FALSE return value corresponds to a failed memory allocation,
+         * which does not allow to discriminate between the failed allocation and non-existing
+         * property conditions.
+         */
+        if (result == FALSE)
+        {
+            Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
+            return -1;
+        }
+
+        if ( *numcol > 0 )
+        {
+            setGraphicObjectProperty(pthis, __GO_DATA_MODEL_X__, tab, jni_double_vector, n1);
+            setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Y__, &tab[n1], jni_double_vector, n1);
+
+            if (*numcol == 3)
+            {
+                setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, &tab[2*n1], jni_double_vector, n1);
+                zCoordinatesSet = 1;
+            }
+            else
+            {
+                zCoordinatesSet = 0;
+            }
+
+            /* Required for now to indicate that the z coordinates have been set or not */
+            setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zCoordinatesSet, jni_int, 1);
+        }
+
+        return 0;
+    }
+    else if (strcmp(type, __GO_RECTANGLE__) == 0)
+    {
+        double* currentUpperLeftPoint;
+        double upperLeftPoint[3];
+        int widthIndex = 2;
+        int size = *numrow * *numcol;
+
+        if ( size != 5 && size != 4 )
+        {
+            Scierror(999, _("Number of elements must be %d (%d if %s coordinate).\n"),4,5,"z");
+            return -1;
+        }
+
+        upperLeftPoint[0] = tab[0];
+        upperLeftPoint[1] = tab[1];
+
+        if ( size == 5 )
+        {
+            upperLeftPoint[2] = tab[2];
+            widthIndex = 3;
+        }
+        else
+        {
+            /*
+             * Needed in order to set the z coordinate if size == 4
+             * Being able to set only the point's x and y coordinates values would avoid doing this.
+             */
+            getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &currentUpperLeftPoint);
+            upperLeftPoint[2] = currentUpperLeftPoint[2];
+        }
+
+        setGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
+
+        /* check that the height and width are positive */
+        if ( tab[widthIndex] < 0.0 || tab[widthIndex + 1] < 0.0 )
+        {
+            Scierror(999,"Width and height must be positive.\n") ;
+            return -1 ;
+        }
+
+        setGraphicObjectProperty(pthis, __GO_WIDTH__, &tab[widthIndex], jni_double, 1);
+        setGraphicObjectProperty(pthis, __GO_HEIGHT__, &tab[widthIndex + 1], jni_double, 1);
+
+        return 0;
+    }
+    else if (strcmp(type, __GO_ARC__) == 0)
+    {
+        double startAngle;
+        double endAngle;
+        double upperLeftPoint[3];
+        double width;
+        double height;
+        double* currentUpperLeftPoint;
+        int size;
+
+        size = *numrow * *numcol;
+
+        if ((size != 7) && (size != 6))
+        {
+            Scierror(999, _("Number of elements must be %d (%d if z coordinate )\n"),6,7);
+            return -1;
+        }
+
+        upperLeftPoint[0] = tab[0];
+        upperLeftPoint[1] = tab[1];
+
+        /*
+         * Setting the data has been made consistent with how it is done for the Rectangle:
+         * it takes into account the size of the input array instead of the parent Axes'
+         * view property. Using the latter led to incorrectly set values when size and view
+         * were not corresponding (for example when size==7, and view==2d).
+         */
+        if (size == 7)
+        {
+            upperLeftPoint[2] = tab[2];
+            width = tab[3];
+            height = tab[4];
+            startAngle = DEG2RAD(tab[5]);
+            endAngle = DEG2RAD(tab[6]);
+        }
+        else
+        {
+            /* Needed in order to set the z coordinate if size == 6 */
+            getGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, jni_double_vector, &currentUpperLeftPoint);
+
+            upperLeftPoint[2] = currentUpperLeftPoint[2];
+            width = tab[2];
+            height = tab[3];
+            startAngle = DEG2RAD(tab[4]);
+            endAngle = DEG2RAD(tab[5]);
+        }
+
+        setGraphicObjectProperty(pthis, __GO_UPPER_LEFT_POINT__, upperLeftPoint, jni_double_vector, 3);
+
+        setGraphicObjectProperty(pthis, __GO_WIDTH__, &width, jni_double, 1);
+        setGraphicObjectProperty(pthis, __GO_HEIGHT__, &height, jni_double, 1);
+
+        setGraphicObjectProperty(pthis, __GO_START_ANGLE__, &startAngle, jni_double, 1);
+        setGraphicObjectProperty(pthis, __GO_END_ANGLE__, &endAngle, jni_double, 1);
+
+        return 0;
+    }
+    else if (strcmp(type, __GO_TEXT__) == 0)
+    {
+        char* parentAxes;
+        double position[3];
+        int iView = 0;
+        int* piView = &iView;
+
+        if ((*numrow * *numcol != 2)&&(*numrow * *numcol != 3))
+        {
+            Scierror(999, _("Number of elements must be %d (%d if %s coordinate).\n"),2,3,"z");
+            return -1;
+        }
+
+        getGraphicObjectProperty(pthis, __GO_PARENT_AXES__, jni_string, &parentAxes);
+        getGraphicObjectProperty(parentAxes, __GO_VIEW__, jni_int, &piView);
+
+        position[0] = tab[0];
+        position[1] = tab[1];
+
+        if (iView)
+        {
+            position[2] = tab[2];
+        }
+        else
+        {
+            /*
+             * Required as the position has 3 coordinates, hence the z-coordinate
+             * is set to its current value, which must be retrieved beforehand.
+             * Avoiding doing this would require being able to set only the x and y
+             * coordinates if required.
+             */
+            double* currentPosition;
+            getGraphicObjectProperty(pthis, __GO_POSITION__, jni_double_vector, &currentPosition);
+            position[2] = currentPosition[2];
+        }
+
+        setGraphicObjectProperty(pthis, __GO_POSITION__, position, jni_double_vector, 3);
+
+        return 0;
+    }
+    else if (strcmp(type, __GO_SEGS__) == 0)
+    {
+        int numArrows;
+        double* arrowPoints = NULL;
+
+        if ((*numcol != 3)&&(*numcol != 2))
+        {
+            Scierror(999, _("Number of columns must be %d (%d if %s coordinate).\n"),2,3,"z");
+            return -1;
+        }
+
+        if (*numrow % 2 != 0)
+        {
+            Scierror(999, _("Number of rows must be a multiple of 2.\n"));
+            return -1;
+        }
+
+
+        numArrows = *numrow/2;
+
+        arrowPoints = (double*) MALLOC(3*numArrows*sizeof(double));
+
+        if (arrowPoints == NULL)
+        {
+            Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
+            return -1;
+        }
+
+        /*
+         * Interlacing ought to be done in the MVC's coordinates
+         * set function to avoid the additional code below.
+         */
+        for (i = 0; i < numArrows; i++)
+        {
+            arrowPoints[3*i] = tab[2*i];
+            arrowPoints[3*i+1] = tab[2*numArrows+2*i];
+
+            if (*numcol == 3)
+            {
+                arrowPoints[3*i+2] = tab[4*numArrows+2*i];
+            }
+            else
+            {
+                arrowPoints[3*i+2] = 0.0;
+            }
+        }
+
+        setGraphicObjectProperty(pthis, __GO_NUMBER_ARROWS__, &numArrows, jni_int, 1);
+
+        setGraphicObjectProperty(pthis, __GO_BASE__, arrowPoints, jni_double_vector, 3*numArrows);
+
+        for (i = 0; i < numArrows; i++)
+        {
+            arrowPoints[3*i] = tab[2*i+1];
+            arrowPoints[3*i+1] = tab[2*numArrows+2*i+1];
+
+            if (*numcol == 3)
+            {
+                arrowPoints[3*i+2] = tab[4*numArrows+2*i+1];
+            }
+            else
+            {
+                arrowPoints[3*i+2] = 0.0;
+            }
+        }
+
+        setGraphicObjectProperty(pthis, __GO_DIRECTION__, arrowPoints, jni_double_vector, 3*numArrows);
+
+        FREE(arrowPoints);
+
+        return 0;
+    }
+    /* DJ.A 2003 */
+    /* SCI_SURFACE has been replaced by the MVC's FAC3D and PLOT3D */
+    else if (strcmp(type, __GO_FAC3D__) == 0)
+    {
+        Scierror(999, _("Unhandled data field\n"));
+        return -1;
+    }
+    else if (strcmp(type, __GO_PLOT3D__) == 0)
+    {
+        Scierror(999, _("Unhandled data field\n"));
+        return -1;
+    }
+    else if (strcmp(type, __GO_MATPLOT__) == 0)
+    {
+        int nx;
+        int ny;
+        int gridSize[4];
+        int result;
+
+        ny = *numrow;
+        nx = *numcol;
+
+        /*
+         * The number of points along each dimension is equal to the z data matrix's
+         * corresponding dimension plus 1
+         */
+        gridSize[0] = nx + 1;
+        gridSize[1] = 1;
+        gridSize[2] = ny + 1;
+        gridSize[3] = 1;
+
+        result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
+
+        if (result == FALSE)
+        {
+            Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
+            return -1;
+        }
+
+        setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Z__, tab, jni_double_vector, nx*ny);
+    }
+    else if (strcmp(type, __GO_FEC__) == 0)
+    {
+        BOOL result;
+        int Nnode;
+        if (*numcol != 3)
+        {
+            Scierror(999, _("Number of columns must be %d.\n"),3);
+            return -1;
+        }
+
+        Nnode = *numrow;
+
+        /* Resizes the data coordinates array if required */
+        result = setGraphicObjectProperty(pthis, __GO_DATA_MODEL_NUM_VERTICES__, &Nnode, jni_int, 1);
+
+        if (result == FALSE)
+        {
+            Scierror(999, _("%s: No more memory.\n"), "sciSetPoint");
+            return -1;
+        }
+
+        setGraphicObjectProperty(pthis, __GO_DATA_MODEL_X__, tab, jni_double_vector, Nnode);
+        setGraphicObjectProperty(pthis, __GO_DATA_MODEL_Y__, &tab[Nnode], jni_double_vector, Nnode);
+        setGraphicObjectProperty(pthis, __GO_DATA_MODEL_VALUES__, &tab[2*Nnode], jni_double_vector, Nnode);
+    }
+    else if (strcmp(type, __GO_FIGURE__) == 0)
+    {
+        printSetGetErrorMessage("data");
+        return -1;
+    }
+    else if (strcmp(type, __GO_AXES__) == 0)
+    {
+        printSetGetErrorMessage("data");
+        return -1;
+    }
+    else if (strcmp(type, __GO_LEGEND__) == 0)
+    {
+        printSetGetErrorMessage("data");
+        return -1;
+    }
+    else if (strcmp(type, __GO_AXIS__) == 0)
+    {
+        printSetGetErrorMessage("data");
+        return -1;
+    }
+    else if (strcmp(type, __GO_COMPOUND__) == 0)
+    {
+        printSetGetErrorMessage("data");
+        return -1;
+    }
+    /* F.Leray 28.05.04 */
+    else if (strcmp(type, __GO_LABEL__) == 0)
+    {
+        printSetGetErrorMessage("data");
+        return -1;
+    }
+    /*
+     * Deactivated for now
+     * Same condition as the default one
+     */
 #if 0
-  static sciPointObj * pobj ;
-  pobj = sciGetFirstTypedSelectedSon(sciGetCurrentFigure(), SCI_SUBWIN);
-  pSUBWIN_FEATURE(pobj)->visible = mode ;
-  sciDrawObj(sciGetCurrentFigure ());
+case SCI_UIMENU:
 #endif
-  return 0;
+    else
+    {
+        printSetGetErrorMessage("data");
+        return -1;
+    }
+
+    return 0;
+}
+
+int sciInitdrawmode( BOOL mode )
+{
+#if 0
+    static sciPointObj * pobj ;
+    pobj = sciGetFirstTypedSelectedSon(sciGetCurrentFigure(), SCI_SUBWIN);
+    pSUBWIN_FEATURE(pobj)->visible = mode ;
+    sciDrawObj(sciGetCurrentFigure ());
+#endif
+    return 0;
 }
 
 int
@@ -2676,38 +2803,38 @@ sciSetdrawmode (BOOL mode)
 {
 // ???
 #if 0
-  static sciPointObj * pobj ;
-  pobj = sciGetFirstTypedSelectedSon(sciGetCurrentFigure(), SCI_SUBWIN);
-  if ( sciGetdrawmode( pobj ) == mode )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitdrawmode( mode ) ;
+    static sciPointObj * pobj ;
+    pobj = sciGetFirstTypedSelectedSon(sciGetCurrentFigure(), SCI_SUBWIN);
+    if ( sciGetdrawmode( pobj ) == mode )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitdrawmode( mode ) ;
 #endif
-  return 0;
+    return 0;
 }
 
 int sciSwitchWindow(int winnum)
 {
 // ???
 #if 0
-  /* find if exist figure winnum */
-  /* une autre methode c est de tester CurXGC->mafigure = NULL */
-  if ( !sciIsExistingFigure(winnum) )
-  {
-    /* Figure winnum don't exist, create it! */
-    if( createFullFigure(&winnum) == NULL)
-    {
-      return -1; /* failed to switch */
-    }
-  }
-  else
-  {
-    sciSetCurrentFigure(getFigureFromIndex(winnum));
-  }
+    /* find if exist figure winnum */
+    /* une autre methode c est de tester CurXGC->mafigure = NULL */
+    if ( !sciIsExistingFigure(winnum) )
+    {
+        /* Figure winnum don't exist, create it! */
+        if( createFullFigure(&winnum) == NULL)
+        {
+            return -1; /* failed to switch */
+        }
+    }
+    else
+    {
+        sciSetCurrentFigure(getFigureFromIndex(winnum));
+    }
 #endif
-  return 0;
+    return 0;
 }
 
 /*----------------------------------------------------------------------------------*/
@@ -2716,7 +2843,7 @@ int sciSwitchWindow(int winnum)
  */
 int sciInitUsedWindow( int winNum )
 {
-  return sciSwitchWindow( winNum ) ; /* create the handle */
+    return sciSwitchWindow( winNum ) ; /* create the handle */
 }
 
 /*----------------------------------------------------------------------------------*/
@@ -2725,125 +2852,142 @@ int sciInitUsedWindow( int winNum )
  */
 int sciSetUsedWindow( int winNum )
 {
-    return 1;
-  /* select or create the window in the driver */
-  if ( sciHasFigures() && sciGetNum( sciGetCurrentFigure() ) == winNum )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    // FIXME
+    abort();
+#if 0
+        return 1;
+    /* select or create the window in the driver */
+    if ( sciHasFigures() && sciGetNum( sciGetCurrentFigure() ) == winNum )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 
-  return sciInitUsedWindow( winNum ) ;
+    return sciInitUsedWindow( winNum ) ;
+#endif
+    return 1;
 }
 
 /*----------------------------------------------------------------------------------*/
 
 
 
-int sciInitIsFilled( sciPointObj * pobj, BOOL isfilled )
+int sciInitIsFilled( char * pobjUID, BOOL isfilled )
 {
-  switch (sciGetEntityType (pobj))
-  {
-  case SCI_LABEL:
-    /* isfilled correspond to several properties in text object */
-    sciInitIsBoxed(  pLABEL_FEATURE(pobj)->text, isfilled ) ;
-    sciInitIsLine(   pLABEL_FEATURE(pobj)->text, isfilled ) ;
-    return sciInitIsFilled( pLABEL_FEATURE(pobj)->text, isfilled ) ;
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pobj)->axes.filled = isfilled;
-    return 0;
-  default:
-    if(sciGetGraphicContext(pobj) != NULL)
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
-      sciGetGraphicContext(pobj)->isfilled = isfilled;
-      return 0;
+    case SCI_LABEL:
+        /* isfilled correspond to several properties in text object */
+        sciInitIsBoxed(  pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
+        sciInitIsLine(   pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
+        return sciInitIsFilled( pLABEL_FEATURE(pobjUID)->text, isfilled ) ;
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->axes.filled = isfilled;
+        return 0;
+    default:
+        if(sciGetGraphicContext(pobjUID) != NULL)
+        {
+            sciGetGraphicContext(pobjUID)->isfilled = isfilled;
+            return 0;
+        }
     }
-  }
 
-  printSetGetErrorMessage("fill_mode");
-  return -1;
+    printSetGetErrorMessage("fill_mode");
+#endif
+    return -1;
 }
 
 /**sciSetIsFilled
  * Sets the filled line existence
  */
 int
-sciSetIsFilled (sciPointObj * pobj, BOOL isfilled)
+sciSetIsFilled (char * pobjUID, BOOL isfilled)
 {
 
-  if ( sciGetIsFilled( pobj ) == isfilled )
-  {
-    return 1 ;
-  }
-  return sciInitIsFilled( pobj, isfilled ) ;
+    if ( sciGetIsFilled( pobjUID ) == isfilled )
+    {
+        return 1 ;
+    }
+    return sciInitIsFilled( pobjUID, isfilled ) ;
 
 }
 
 
-int sciInitBoxType( sciPointObj * pobj, EAxesBoxType type )
+int sciInitBoxType( char * pobjUID, EAxesBoxType type )
 {
-  switch (sciGetEntityType (pobj))
-  {
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
+    {
     case SCI_SUBWIN:
-      pSUBWIN_FEATURE(pobj)->axes.rect = type ;
-      /* redondant information in scilab :'( */
-      switch ( type )
-      {
+        pSUBWIN_FEATURE(pobjUID)->axes.rect = type ;
+        /* redondant information in scilab :'( */
+        switch ( type )
+        {
         case BT_OFF:
-          pSUBWIN_FEATURE(pobj)->axes.flag[2] = 0 ;
-          break ;
+            pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 0 ;
+            break ;
         case BT_ON:
-          pSUBWIN_FEATURE(pobj)->axes.flag[2] = 4 ;
-          break ;
+            pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 4 ;
+            break ;
         case BT_HIDDEN_AXES:
-          pSUBWIN_FEATURE(pobj)->axes.flag[2] = 2 ;
-          break ;
+            pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 2 ;
+            break ;
         case BT_BACK_HALF:
-          pSUBWIN_FEATURE(pobj)->axes.flag[2] = 3 ;
-          break ;
-      }
-      return 0;
-      break;
+            pSUBWIN_FEATURE(pobjUID)->axes.flag[2] = 3 ;
+            break ;
+        }
+        return 0;
+        break;
     default:
-      printSetGetErrorMessage("box_type");
-      return -1 ;
-      break;
-  }
+        printSetGetErrorMessage("box_type");
+        return -1 ;
+        break;
+    }
+#endif
+        return -1 ;
 }
 
 /* set the property of the axes box  */
-int sciSetBoxType( sciPointObj * pobj, EAxesBoxType type )
+int sciSetBoxType( char * pobjUID, EAxesBoxType type )
 {
 
-  if ( sciGetBoxType( pobj ) == type )
-  {
-    return 1 ;
-  }
-  return sciInitBoxType( pobj, type ) ;
+    if ( sciGetBoxType( pobjUID ) == type )
+    {
+        return 1 ;
+    }
+    return sciInitBoxType( pobjUID, type ) ;
 
 }
 
 
-int sciInitIsBoxed( sciPointObj * pobj, BOOL isboxed )
+int sciInitIsBoxed( char * pobjUID, BOOL isboxed )
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
     case SCI_TEXT:
-      pTEXT_FEATURE(pobj)->isboxed = isboxed;
-      return 0;
-      break;
+        pTEXT_FEATURE(pobjUID)->isboxed = isboxed;
+        return 0;
+        break;
     case SCI_SUBWIN:
-      Scierror(999, _("%s: please use %s instead.\n"),"sciSetIsBoxed","sciSetBoxType");
-      if ( isboxed )
-      {
-        pSUBWIN_FEATURE(pobj)->axes.rect = BT_ON ;
-      }
-      else
-      {
-        pSUBWIN_FEATURE(pobj)->axes.rect = BT_OFF ;
-      }
-      return 0;
-      break;
+        Scierror(999, _("%s: please use %s instead.\n"),"sciSetIsBoxed","sciSetBoxType");
+        if ( isboxed )
+        {
+            pSUBWIN_FEATURE(pobjUID)->axes.rect = BT_ON ;
+        }
+        else
+        {
+            pSUBWIN_FEATURE(pobjUID)->axes.rect = BT_OFF ;
+        }
+        return 0;
+        break;
     case SCI_LABEL:
     case SCI_POLYLINE:
     case SCI_RECTANGLE:
@@ -2858,575 +3002,645 @@ int sciInitIsBoxed( sciPointObj * pobj, BOOL isboxed )
     case SCI_AGREG:
     case SCI_UIMENU:
     default:
-      printSetGetErrorMessage("box_type");
-      return -1;
-      break;
+        printSetGetErrorMessage("box_type");
+        return -1;
+        break;
     }
-
+#endif
+        return -1 ;
 }
 
 /**sciSetIsBoxed
  * Sets the box existence
  */
 int
-sciSetIsBoxed (sciPointObj * pobj, BOOL isboxed)
+sciSetIsBoxed (char * pobjUID, BOOL isboxed)
 {
 
-  if ( sciGetIsBoxed( pobj ) == isboxed )
-  {
-    return 1 ;
-  }
-  return sciInitIsBoxed( pobj, isboxed ) ;
+    if ( sciGetIsBoxed( pobjUID ) == isboxed )
+    {
+        return 1 ;
+    }
+    return sciInitIsBoxed( pobjUID, isboxed ) ;
 
 }
 
 
 int
-sciInitNbXSubTics(sciPointObj * pobj, int nbsubtics)
+sciInitNbXSubTics(char * pobjUID, int nbsubtics)
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
     case SCI_SUBWIN:
-      pSUBWIN_FEATURE(pobj)->axes.nbsubtics[0] = nbsubtics;
-      break;
+        pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[0] = nbsubtics;
+        break;
     default:
-      printSetGetErrorMessage("subwin_type required");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("subwin_type required");
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetNbXSubTics
  * Sets the number of x subticks
  */
 int
-sciSetNbXSubTics(sciPointObj * pobj, int nbsubtics)
+sciSetNbXSubTics(char * pobjUID, int nbsubtics)
 {
-  int curr_nbsubtics[3];
+    int curr_nbsubtics[3];
 
-  sciGetNbSubTics( pobj,  curr_nbsubtics);
+    sciGetNbSubTics( pobjUID,  curr_nbsubtics);
 
-  if ( curr_nbsubtics[0] == nbsubtics )
-  {
-    return 1 ;
-  }
-  return sciInitNbXSubTics( pobj, nbsubtics ) ;
+    if ( curr_nbsubtics[0] == nbsubtics )
+    {
+        return 1 ;
+    }
+    return sciInitNbXSubTics( pobjUID, nbsubtics ) ;
 }
 
 int
-sciInitNbYSubTics(sciPointObj * pobj, int nbsubtics)
+sciInitNbYSubTics(char * pobjUID, int nbsubtics)
 {
-  switch (sciGetEntityType (pobj))
+// FIXME
+    abort();
+#if 0
+    switch (sciGetEntityType (pobjUID))
     {
     case SCI_SUBWIN:
-      pSUBWIN_FEATURE(pobj)->axes.nbsubtics[1] = nbsubtics;
-      break;
+        pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[1] = nbsubtics;
+        break;
     default:
-      printSetGetErrorMessage("subwin_type required");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("subwin_type required");
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetNbYSubTics
  * Sets the number of y subticks
  */
 int
-sciSetNbYSubTics(sciPointObj * pobj, int nbsubtics)
+sciSetNbYSubTics(char * pobjUID, int nbsubtics)
 {
-  int curr_nbsubtics[3];
+    int curr_nbsubtics[3];
 
-  sciGetNbSubTics( pobj,  curr_nbsubtics);
+    sciGetNbSubTics( pobjUID,  curr_nbsubtics);
 
-  if ( curr_nbsubtics[1] == nbsubtics )
-  {
-    return 1 ;
-  }
-  return sciInitNbYSubTics( pobj, nbsubtics ) ;
+    if ( curr_nbsubtics[1] == nbsubtics )
+    {
+        return 1 ;
+    }
+    return sciInitNbYSubTics( pobjUID, nbsubtics ) ;
 }
 
 int
-sciInitNbZSubTics(sciPointObj * pobj, int nbsubtics)
+sciInitNbZSubTics(char * pobjUID, int nbsubtics)
 {
-  switch (sciGetEntityType (pobj))
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
     {
     case SCI_SUBWIN:
-      pSUBWIN_FEATURE(pobj)->axes.nbsubtics[2] = nbsubtics;
-      break;
+        pSUBWIN_FEATURE(pobjUID)->axes.nbsubtics[2] = nbsubtics;
+        break;
     default:
-      printSetGetErrorMessage("subwin_type required");
-      return -1 ;
-      break;
+        printSetGetErrorMessage("subwin_type required");
+        return -1 ;
+        break;
     }
-  return 0 ;
+#endif
+    return 0 ;
 }
 
 /**sciSetNbZSubTics
  * Sets the number of x subticks
  */
 int
-sciSetNbZSubTics(sciPointObj * pobj, int nbsubtics)
+sciSetNbZSubTics(char * pobjUID, int nbsubtics)
 {
-  int curr_nbsubtics[3];
+    int curr_nbsubtics[3];
 
-  sciGetNbSubTics( pobj,  curr_nbsubtics);
+    sciGetNbSubTics( pobjUID,  curr_nbsubtics);
 
-  if ( curr_nbsubtics[2] == nbsubtics )
-  {
-    return 1 ;
-  }
-  return sciInitNbZSubTics( pobj, nbsubtics ) ;
+    if ( curr_nbsubtics[2] == nbsubtics )
+    {
+        return 1 ;
+    }
+    return sciInitNbZSubTics( pobjUID, nbsubtics ) ;
 }
 
 
 int
-sciSetInterpVector(sciPointObj * pobj, int size, int * value)
+sciSetInterpVector(char * pobjUID, int size, int * value)
 {
-  int i;
-
-  FREE(pPOLYLINE_FEATURE(pobj)->scvector);
+    // FIXME
+    abort();
+#if 0
+        int i;
 
-  if((pPOLYLINE_FEATURE(pobj)->scvector = MALLOC(size*sizeof(int)))==NULL){
-    Scierror(999, _("%s: No more memory.\n"), "sciSetInterpVector") ;
-    return -1;
-  }
+    FREE(pPOLYLINE_FEATURE(pobjUID)->scvector);
 
-  for(i=0;i<size;i++)
-    pPOLYLINE_FEATURE(pobj)->scvector[i] = value[i];
+    if((pPOLYLINE_FEATURE(pobjUID)->scvector = MALLOC(size*sizeof(int)))==NULL){
+        Scierror(999, _("%s: No more memory.\n"), "sciSetInterpVector") ;
+        return -1;
+    }
 
-  return 0;
+    for(i=0;i<size;i++)
+        pPOLYLINE_FEATURE(pobjUID)->scvector[i] = value[i];
+#endif
+    return 0;
 }
 
-int sciInitAutoRotation( sciPointObj * pObj, BOOL value )
+int sciInitAutoRotation( char * pobjUID, BOOL value )
 {
-  switch (sciGetEntityType (pObj))
-  {
-  case SCI_LABEL:
-    pLABEL_FEATURE(pObj)->auto_rotation = value ;
-    return 0;
-  case SCI_POLYLINE:
-  case SCI_RECTANGLE:
-  case SCI_ARC:
-  case SCI_TEXT:
-  case SCI_FIGURE:
-  case SCI_SUBWIN:
-  case SCI_SURFACE:
-  case SCI_AXES:
-  case SCI_FEC:
-  case SCI_SEGS:
-  case SCI_LEGEND:
-  case SCI_GRAYPLOT:
-  case SCI_AGREG:
-  case SCI_UIMENU:
-  default:
-    printSetGetErrorMessage("auto_rotation");
-    return -1 ;
-    break;
-  }
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
+    {
+    case SCI_LABEL:
+        pLABEL_FEATURE(pobjUID)->auto_rotation = value ;
+        return 0;
+    case SCI_POLYLINE:
+    case SCI_RECTANGLE:
+    case SCI_ARC:
+    case SCI_TEXT:
+    case SCI_FIGURE:
+    case SCI_SUBWIN:
+    case SCI_SURFACE:
+    case SCI_AXES:
+    case SCI_FEC:
+    case SCI_SEGS:
+    case SCI_LEGEND:
+    case SCI_GRAYPLOT:
+    case SCI_AGREG:
+    case SCI_UIMENU:
+    default:
+        printSetGetErrorMessage("auto_rotation");
+        return -1 ;
+        break;
+    }
+#endif
+        return -1;
 
 }
 
 /* set the auto_rotation property of an object */
-int sciSetAutoRotation ( sciPointObj * pObj, BOOL value )
+int sciSetAutoRotation ( char * pobjUID, BOOL value )
 {
 
-  if ( sciGetAutoRotation( pObj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitAutoRotation( pObj, value ) ;
+    if ( sciGetAutoRotation( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitAutoRotation( pobjUID, value ) ;
 
 }
 
 
-int sciInitAutoPosition( sciPointObj * pObj, BOOL value )
+int sciInitAutoPosition( char * pobjUID, BOOL value )
 {
-  switch (sciGetEntityType (pObj))
-  {
-  case SCI_LABEL:
-    pLABEL_FEATURE(pObj)->auto_position = value ;
-    return 0;
-  case SCI_POLYLINE:
-  case SCI_RECTANGLE:
-  case SCI_ARC:
-  case SCI_TEXT:
-  case SCI_FIGURE:
-  case SCI_SUBWIN:
-  case SCI_SURFACE:
-  case SCI_AXES:
-  case SCI_FEC:
-  case SCI_SEGS:
-  case SCI_LEGEND:
-  case SCI_GRAYPLOT:
-  case SCI_AGREG:
-  case SCI_UIMENU:
-  default:
-    printSetGetErrorMessage("auto_position");
-    return -1 ;
-    break;
-  }
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
+    {
+    case SCI_LABEL:
+        pLABEL_FEATURE(pobjUID)->auto_position = value ;
+        return 0;
+    case SCI_POLYLINE:
+    case SCI_RECTANGLE:
+    case SCI_ARC:
+    case SCI_TEXT:
+    case SCI_FIGURE:
+    case SCI_SUBWIN:
+    case SCI_SURFACE:
+    case SCI_AXES:
+    case SCI_FEC:
+    case SCI_SEGS:
+    case SCI_LEGEND:
+    case SCI_GRAYPLOT:
+    case SCI_AGREG:
+    case SCI_UIMENU:
+    default:
+        printSetGetErrorMessage("auto_position");
+        return -1 ;
+        break;
+    }
+#endif
 
 }
 
 /* set the auto_position property of an object */
-int sciSetAutoPosition ( sciPointObj * pObj, BOOL value )
+int sciSetAutoPosition ( char * pobjUID, BOOL value )
 {
 
-  if ( sciGetAutoPosition( pObj ) == value )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitAutoPosition( pObj, value ) ;
+    if ( sciGetAutoPosition( pobjUID ) == value )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitAutoPosition( pobjUID, value ) ;
 
 }
 
 /*---------------------------------------------------------------------------*/
 int checkPercent( char * string )
 {
-  /* check for the percent in the string */
-  char * firstPercent  = strchr( string, '%' ) ;
+    /* check for the percent in the string */
+    char * firstPercent  = strchr( string, '%' ) ;
 
-  if ( firstPercent == NULL )
-  {
-    /* no % character found */
-    return 0 ;
-  }
-  else if ( firstPercent[1] != 'd' )
-  {
-    /* a %something with something != d has been found */
-    return -1 ;
-  }
-  else
-  {
-    /* here we have found a first %d, check if there is not any more % */
-    firstPercent++ ;
-    firstPercent = strchr( firstPercent, '%' ) ;
     if ( firstPercent == NULL )
     {
-      /* no other % character found */
-      return 1 ;
+        /* no % character found */
+        return 0 ;
+    }
+    else if ( firstPercent[1] != 'd' )
+    {
+        /* a %something with something != d has been found */
+        return -1 ;
     }
     else
     {
-      return -1 ;
+        /* here we have found a first %d, check if there is not any more % */
+        firstPercent++ ;
+        firstPercent = strchr( firstPercent, '%' ) ;
+        if ( firstPercent == NULL )
+        {
+            /* no other % character found */
+            return 1 ;
+        }
+        else
+        {
+            return -1 ;
+        }
     }
-  }
 }
 /*---------------------------------------------------------------------------*/
-int sciInitAutoSize( sciPointObj * pObj, BOOL autoSize )
+int sciInitAutoSize( char * pobjUID, BOOL autoSize )
 {
-  switch ( sciGetEntityType (pObj) )
-  {
-  case SCI_TEXT:
-    pTEXT_FEATURE(pObj)->autoSize = autoSize ;
-    return 0 ;
-  default:
-   printSetGetErrorMessage("text_box_mode");
-    return -1 ;
-    break;
-  }
+// FIXME
+#if 0
+    switch ( sciGetEntityType (pobjUID) )
+    {
+    case SCI_TEXT:
+        pTEXT_FEATURE(pobjUID)->autoSize = autoSize ;
+        return 0 ;
+    default:
+        printSetGetErrorMessage("text_box_mode");
+        return -1 ;
+        break;
+    }
+#endif
+    return -1;
 
 }
 /*---------------------------------------------------------------------------*/
-int sciSetAutoSize( sciPointObj * pObj, BOOL autoSize )
+int sciSetAutoSize( char * pobjUID, BOOL autoSize )
 {
-  if ( sciGetAutoSize( pObj ) == autoSize )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitAutoSize( pObj, autoSize ) ;
+    if ( sciGetAutoSize( pobjUID ) == autoSize )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitAutoSize( pobjUID, autoSize ) ;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitAlignment( sciPointObj * pObj, sciTextAlignment align )
+int sciInitAlignment( char * pobjUID, sciTextAlignment align )
 {
-  switch (sciGetEntityType (pObj))
-  {
-  case SCI_TEXT:
-    pTEXT_FEATURE(pObj)->stringsAlign = align ;
-    return 0 ;
-  default:
-    printSetGetErrorMessage("alignment");
-    return -1 ;
-  }
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType (pobjUID))
+    {
+    case SCI_TEXT:
+        pTEXT_FEATURE(pobjUID)->stringsAlign = align ;
+        return 0 ;
+    default:
+        printSetGetErrorMessage("alignment");
+        return -1 ;
+    }
+#endif
 
 }
 /*-----------------------------------------------------------------------------------*/
-int sciSetAlignment( sciPointObj * pObj, sciTextAlignment align )
+int sciSetAlignment( char * pobjUID, sciTextAlignment align )
 {
-  if ( sciGetAlignment( pObj ) == align )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitAlignment( pObj, align ) ;
+    if ( sciGetAlignment( pobjUID ) == align )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitAlignment( pobjUID, align ) ;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitUserSize( sciPointObj * pObj, double width, double height )
+int sciInitUserSize( char * pobjUID, double width, double height )
 {
-  switch( sciGetEntityType( pObj ) )
-  {
-  case SCI_TEXT:
-    pTEXT_FEATURE(pObj)->userSize[0] = width ;
-    pTEXT_FEATURE(pObj)->userSize[1] = height ;
-    return 0 ;
-  default:
-    printSetGetErrorMessage("text_box");
-    return -1 ;
-  }
+    // FIXME
+    abort();
+#if 0
+        switch( sciGetEntityType( pobjUID ) )
+    {
+    case SCI_TEXT:
+        pTEXT_FEATURE(pobjUID)->userSize[0] = width ;
+        pTEXT_FEATURE(pobjUID)->userSize[1] = height ;
+        return 0 ;
+    default:
+        printSetGetErrorMessage("text_box");
+        return -1 ;
+    }
+#endif
+        return -1;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciSetUserSize( sciPointObj * pObj, double width, double height )
-{
-  double curWidth  ;
-  double curHeight ;
-  sciGetUserSize( pObj, &curWidth, &curHeight ) ;
-  if ( curWidth == width && curHeight == height )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitUserSize( pObj, width, height ) ;
+int sciSetUserSize( char * pobjUID, double width, double height )
+{
+    double curWidth  ;
+    double curHeight ;
+    sciGetUserSize( pobjUID, &curWidth, &curHeight ) ;
+    if ( curWidth == width && curHeight == height )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitUserSize( pobjUID, width, height ) ;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitCenterPos( sciPointObj * pObj, BOOL newCP )
+int sciInitCenterPos( char * pobjUID, BOOL newCP )
 {
-  switch( sciGetEntityType( pObj ) )
-  {
-  case SCI_TEXT:
-    pTEXT_FEATURE(pObj)->centeredPos = newCP ;
-    return 0 ;
-  default:
-    printSetGetErrorMessage("data");
-    return -1 ;
-  }
+    // FIXME
+    abort();
+#if 0
+        switch( sciGetEntityType( pobjUID ) )
+    {
+    case SCI_TEXT:
+        pTEXT_FEATURE(pobjUID)->centeredPos = newCP ;
+        return 0 ;
+    default:
+        printSetGetErrorMessage("data");
+        return -1 ;
+    }
+#endif
+        return -1;
 
 }
 /*-----------------------------------------------------------------------------------*/
-int sciSetCenterPos( sciPointObj * pObj, BOOL newCP )
+int sciSetCenterPos( char * pobjUID, BOOL newCP )
 {
-  if ( sciGetCenterPos( pObj ) == newCP )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitCenterPos( pObj, newCP ) ;
+    if ( sciGetCenterPos( pobjUID ) == newCP )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitCenterPos( pobjUID, newCP ) ;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitIs3d(  sciPointObj * pObj, BOOL is3d )
-{
-   switch( sciGetEntityType( pObj ) )
-   {
-   case SCI_SUBWIN:
-     if ( is3d )
-     {
-       pSUBWIN_FEATURE (pObj)->is3d = TRUE ;
-       Obj_RedrawNewAngle( pObj,
-                           pSUBWIN_FEATURE (pObj)->alpha_kp,
-                           pSUBWIN_FEATURE (pObj)->theta_kp ) ;
-     }
-     else
-     {
-       /* switch to 2d */
-       if ( sciGetSurface(pObj) == NULL)
-       {
-         pSUBWIN_FEATURE (pObj)->is3d = FALSE;
-         pSUBWIN_FEATURE (pObj)->project[2]= 0;
-       }
-       pSUBWIN_FEATURE (pObj)->theta_kp = pSUBWIN_FEATURE (pObj)->theta;
-       pSUBWIN_FEATURE (pObj)->alpha_kp = pSUBWIN_FEATURE (pObj)->alpha;
-       pSUBWIN_FEATURE (pObj)->alpha = 0.0;
-       pSUBWIN_FEATURE (pObj)->theta = 270.0;
-       pSUBWIN_FEATURE(pObj)->is3d = FALSE;
-       return 0 ;
-     }
-     return 0 ;
-   case SCI_TEXT:
-     pTEXT_FEATURE( pObj )->is3d = is3d ;
-     return 0 ;
-   case SCI_LABEL:
-     return sciInitIs3d( pLABEL_FEATURE( pObj )->text, is3d ) ;
-   default:
-     printSetGetErrorMessage("view");
-     return -1 ;
-   }
+int sciInitIs3d(  char * pobjUID, BOOL is3d )
+{
+    // FIXME
+    abort();
+#if 0
+        switch( sciGetEntityType( pobjUID ) )
+    {
+    case SCI_SUBWIN:
+        if ( is3d )
+        {
+            pSUBWIN_FEATURE (pobjUID)->is3d = TRUE ;
+            Obj_RedrawNewAngle( pobjUID,
+                                pSUBWIN_FEATURE (pobjUID)->alpha_kp,
+                                pSUBWIN_FEATURE (pobjUID)->theta_kp ) ;
+        }
+        else
+        {
+            /* switch to 2d */
+            if ( sciGetSurface(pobjUID) == NULL)
+            {
+                pSUBWIN_FEATURE (pobjUID)->is3d = FALSE;
+                pSUBWIN_FEATURE (pobjUID)->project[2]= 0;
+            }
+            pSUBWIN_FEATURE (pobjUID)->theta_kp = pSUBWIN_FEATURE (pobjUID)->theta;
+            pSUBWIN_FEATURE (pobjUID)->alpha_kp = pSUBWIN_FEATURE (pobjUID)->alpha;
+            pSUBWIN_FEATURE (pobjUID)->alpha = 0.0;
+            pSUBWIN_FEATURE (pobjUID)->theta = 270.0;
+            pSUBWIN_FEATURE(pobjUID)->is3d = FALSE;
+            return 0 ;
+        }
+        return 0 ;
+    case SCI_TEXT:
+        pTEXT_FEATURE( pobjUID )->is3d = is3d ;
+        return 0 ;
+    case SCI_LABEL:
+        return sciInitIs3d( pLABEL_FEATURE( pobjUID )->text, is3d ) ;
+    default:
+        printSetGetErrorMessage("view");
+        return -1 ;
+    }
+#endif
+        return -1;
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * Force an object to be displayed in 2d or 3d mode.
  */
-int sciSetIs3d( sciPointObj * pObj, BOOL is3d )
+int sciSetIs3d( char * pobjUID, BOOL is3d )
 {
-  if ( sciGetIs3d( pObj ) == is3d )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitIs3d( pObj, is3d ) ;
+    if ( sciGetIs3d( pobjUID ) == is3d )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitIs3d( pobjUID, is3d ) ;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitHiddenColor( sciPointObj * pObj, int newColor )
+int sciInitHiddenColor( char * pobjUID, int newColor )
 {
-  if(!sciCheckColorIndex(pObj, newColor)) { return -1;}
+    // FIXME
+    abort();
+#if 0
+        if(!sciCheckColorIndex(pobjUID, newColor)) { return -1;}
 
-  switch( sciGetEntityType( pObj ) )
-  {
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pObj)->hiddencolor = newColor;
-    return 0 ;
-  case SCI_SURFACE:
-    pSURFACE_FEATURE(pObj)->hiddencolor = newColor;
-    return 0;
-  default:
-    printSetGetErrorMessage("hidden_color");
-    return -1 ;
-  }
+    switch( sciGetEntityType( pobjUID ) )
+    {
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->hiddencolor = newColor;
+        return 0 ;
+    case SCI_SURFACE:
+        pSURFACE_FEATURE(pobjUID)->hiddencolor = newColor;
+        return 0;
+    default:
+        printSetGetErrorMessage("hidden_color");
+        return -1 ;
+    }
+#endif
+    return -1;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciSetHiddenColor( sciPointObj * pObj, int newColor )
+int sciSetHiddenColor( char * pobjUID, int newColor )
 {
-  if ( sciGetHiddenColor( pObj ) == newColor )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitHiddenColor( pObj, newColor ) ;
+    if ( sciGetHiddenColor( pobjUID ) == newColor )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitHiddenColor( pobjUID, newColor ) ;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitHiddenAxisColor( sciPointObj * pObj, int newColor )
+int sciInitHiddenAxisColor( char * pobjUID, int newColor )
 {
-  int m = sciGetNumColors(pObj);
-  if(newColor < -2 || newColor > m + 2) return 0;
+    // FIXME
+    abort();
+#if 0
+        int m = sciGetNumColors(pobjUID);
+    if(newColor < -2 || newColor > m + 2) return 0;
 
-  newColor = sciSetGoodIndex(pObj,newColor);
+    newColor = sciSetGoodIndex(pobjUID,newColor);
 
-  switch( sciGetEntityType( pObj ) )
-  {
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pObj)->axes.hiddenAxisColor = Max (0, Min (newColor - 1, m + 1));
-    return 0 ;
-  default:
-    printSetGetErrorMessage("hidden_axis_color");
-    return -1 ;
-  }
+    switch( sciGetEntityType( pobjUID ) )
+    {
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->axes.hiddenAxisColor = Max (0, Min (newColor - 1, m + 1));
+        return 0 ;
+    default:
+        printSetGetErrorMessage("hidden_axis_color");
+        return -1 ;
+    }
+#endif
+    return -1;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciSetHiddenAxisColor( sciPointObj * pObj, int newColor )
+int sciSetHiddenAxisColor( char * pobjUID, int newColor )
 {
-  if ( sciGetHiddenAxisColor( pObj ) == newColor )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitHiddenAxisColor( pObj, newColor ) ;
+    if ( sciGetHiddenAxisColor( pobjUID ) == newColor )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitHiddenAxisColor( pobjUID, newColor ) ;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitGridStyle( sciPointObj * pObj, int xStyle, int yStyle, int zStyle )
+int sciInitGridStyle( char * pobjUID, int xStyle, int yStyle, int zStyle )
 {
-  if (    !sciCheckColorIndex(pObj, xStyle)
-       || !sciCheckColorIndex(pObj, yStyle)
-       || !sciCheckColorIndex(pObj, zStyle))
-  {
+    // FIXME
+    abort();
+#if 0
+        if (    !sciCheckColorIndex(pobjUID, xStyle)
+            || !sciCheckColorIndex(pobjUID, yStyle)
+            || !sciCheckColorIndex(pobjUID, zStyle))
+    {
+        return -1;
+    }
+
+    switch( sciGetEntityType( pobjUID ) )
+    {
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->grid[0] = xStyle ;
+        pSUBWIN_FEATURE(pobjUID)->grid[1] = yStyle ;
+        pSUBWIN_FEATURE(pobjUID)->grid[2] = zStyle ;
+        return 0 ;
+    default:
+        printSetGetErrorMessage("grid");
+        return -1 ;
+    }
+#endif
     return -1;
-  }
-
-  switch( sciGetEntityType( pObj ) )
-  {
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pObj)->grid[0] = xStyle ;
-    pSUBWIN_FEATURE(pObj)->grid[1] = yStyle ;
-    pSUBWIN_FEATURE(pObj)->grid[2] = zStyle ;
-    return 0 ;
-  default:
-   printSetGetErrorMessage("grid");
-    return -1 ;
-  }
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * Set the grid of an axes object
  */
-int sciSetGridStyle( sciPointObj * pObj, int xStyle, int yStyle, int zStyle )
-{
-  int curX ;
-  int curY ;
-  int curZ ;
-  sciGetGridStyle( pObj, &curX, &curY, &curZ ) ;
-  if ( curX == xStyle && curY == yStyle && curZ == zStyle )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
-  return sciInitGridStyle( pObj, xStyle, yStyle, zStyle ) ;
+int sciSetGridStyle( char * pobjUID, int xStyle, int yStyle, int zStyle )
+{
+    int curX ;
+    int curY ;
+    int curZ ;
+    sciGetGridStyle( pobjUID, &curX, &curY, &curZ ) ;
+    if ( curX == xStyle && curY == yStyle && curZ == zStyle )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
+    return sciInitGridStyle( pobjUID, xStyle, yStyle, zStyle ) ;
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * Set the viewport property of a figure.
  * Effective only if the auto_resize property is enable
  */
-int sciSetViewport( sciPointObj * pObj, const int viewport[4] )
+int sciSetViewport( char * pobjUID, const int viewport[4] )
 {
-  switch( sciGetEntityType( pObj ) )
-  {
-  case SCI_FIGURE:
-    if (isFigureModel(pObj->UID))
-    {
-      pFIGURE_FEATURE(pObj)->pModelData->viewport[0] = viewport[0];
-      pFIGURE_FEATURE(pObj)->pModelData->viewport[1] = viewport[1];
-      pFIGURE_FEATURE(pObj)->pModelData->viewport[2] = viewport[2];
-      pFIGURE_FEATURE(pObj)->pModelData->viewport[3] = viewport[3];
-    }
-    else
+    // FIXME
+    abort();
+#if 0
+        switch( sciGetEntityType( pobjUID ) )
     {
-      sciSetJavaViewport(pObj, viewport);
+    case SCI_FIGURE:
+        if (isFigureModel(pobjUID))
+        {
+            pFIGURE_FEATURE(pobjUID)->pModelData->viewport[0] = viewport[0];
+            pFIGURE_FEATURE(pobjUID)->pModelData->viewport[1] = viewport[1];
+            pFIGURE_FEATURE(pobjUID)->pModelData->viewport[2] = viewport[2];
+            pFIGURE_FEATURE(pobjUID)->pModelData->viewport[3] = viewport[3];
+        }
+        else
+        {
+            sciSetJavaViewport(pobjUID, viewport);
+        }
+        return 0;
+    default:
+        printSetGetErrorMessage("viewport");
+        return -1 ;
     }
-    return 0;
-  default:
-    printSetGetErrorMessage("viewport");
-    return -1 ;
-  }
-
+#endif
+        return -1;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitInfoMessage(sciPointObj * pObj, const char * newMessage)
+int sciInitInfoMessage(char * pobjUID, const char * newMessage)
 {
-       if ( sciGetEntityType( pObj ) == SCI_FIGURE)
+    // FIXME
+    abort();
+#if 0
+       if ( sciGetEntityType( pobjUID ) == SCI_FIGURE)
        {
 
                /* first case newName is NULL */
                if (newMessage == NULL)
                {
                        /* Just set an empty title for the physical window if needed */
-                       if(isFigureModel(pObj->UID))
+                       if(isFigureModel(pobjUID))
                        {
-                               pFIGURE_FEATURE(pObj)->pModelData->infoMessage = NULL;
+                               pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = NULL;
                        }
                        else
                        {
-                               sciSetJavaInfoMessage(pObj, "");
+                               sciSetJavaInfoMessage(pobjUID, "");
                        }
 
                        return 0;
                }
 
-               if (isFigureModel(pObj->UID))
+               if (isFigureModel(pobjUID))
                {
                        /* Copy the message into the special data */
                        int newMessageLength = (int) strlen(newMessage);
-                       pFIGURE_FEATURE(pObj)->pModelData->infoMessage = MALLOC((newMessageLength + 1) * sizeof(char));
-                       if (pFIGURE_FEATURE(pObj)->pModelData->infoMessage != NULL)
+                       pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = MALLOC((newMessageLength + 1) * sizeof(char));
+                       if (pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage != NULL)
                        {
-                               strcpy(pFIGURE_FEATURE(pObj)->pModelData->infoMessage, newMessage);
+                               strcpy(pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage, newMessage);
                        }
                }
                else
                {
                        /* Copy in the Java data */
-                       sciSetJavaInfoMessage(pObj, newMessage);
+                       sciSetJavaInfoMessage(pobjUID, newMessage);
                }
 
                return 0 ;
@@ -3436,385 +3650,440 @@ int sciInitInfoMessage(sciPointObj * pObj, const char * newMessage)
                printSetGetErrorMessage("info_message");
                return -1;
        }
+#endif
+        return -1;
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * Modify the string in the info bar of the graphic window
  */
-int sciSetInfoMessage( sciPointObj * pObj, const char * newMessage )
+int sciSetInfoMessage( char * pobjUID, const char * newMessage )
 {
-  if (isFigureModel(pObj->UID) && pFIGURE_FEATURE(pObj)->pModelData->infoMessage != NULL)
+    // FIXME
+    abort();
+#if 0
+        if (isFigureModel(pobjUID) && pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage != NULL)
        {
-               FREE(pFIGURE_FEATURE(pObj)->pModelData->infoMessage);
-               pFIGURE_FEATURE(pObj)->pModelData->infoMessage = NULL;
+               FREE(pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage);
+               pFIGURE_FEATURE(pobjUID)->pModelData->infoMessage = NULL;
        }
-       return sciInitInfoMessage(pObj, newMessage);
+       return sciInitInfoMessage(pobjUID, newMessage);
+#endif
+    return -1;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitEventHandler( sciPointObj * pObj, char * name )
+int sciInitEventHandler( char * pobjUID, char * name )
 {
-  if( sciGetEntityType( pObj ) == SCI_FIGURE)
+    // FIXME
+    abort();
+#if 0
+        if( sciGetEntityType( pobjUID ) == SCI_FIGURE)
     {
-      sciFigure * ppFigure = pFIGURE_FEATURE(pObj) ;
+        sciFigure * ppFigure = pFIGURE_FEATURE(pobjUID) ;
 
-      if ( ppFigure == NULL )
-       {
-         Scierror(999, _("%s: No more memory.\n"), "sciInitEventHandler") ;
-         return -1 ;
-       }
+        if ( ppFigure == NULL )
+        {
+            Scierror(999, _("%s: No more memory.\n"), "sciInitEventHandler") ;
+            return -1 ;
+        }
 
-      if ( ppFigure->eventHandler != NULL )
-       {
-         FREE(ppFigure->eventHandler);
-       }
+        if ( ppFigure->eventHandler != NULL )
+        {
+            FREE(ppFigure->eventHandler);
+        }
 
-      ppFigure->eventHandler = strdup(name);
+        ppFigure->eventHandler = strdup(name);
 
-      /* Java is called to set the listener */
-      if (!isFigureModel(pObj->UID))
+        /* Java is called to set the listener */
+        if (!isFigureModel(pobjUID))
         {
-          setFigureEventHandler(sciGetNum(pObj), name);
+            setFigureEventHandler(sciGetNum(pobjUID), name);
         }
 
-      if ( strcmp( name, "" ) == 0 )
-       {
-         sciInitIsEventHandlerEnable( pObj, FALSE ) ;
-       }
+        if ( strcmp( name, "" ) == 0 )
+        {
+            sciInitIsEventHandlerEnable( pobjUID, FALSE ) ;
+        }
 
-      return 0 ;
+        return 0 ;
     }
-  else
+    else
     {
-      printSetGetErrorMessage("event_handler");
-      return -1 ;
+        printSetGetErrorMessage("event_handler");
+        return -1 ;
     }
-
+#endif
+        return -1;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciSetEventHandler( sciPointObj * pObj, char * name )
+int sciSetEventHandler( char * pobjUID, char * name )
 {
-  if ( strcmp( sciGetEventHandler(pObj), name ) == 0 )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( strcmp( sciGetEventHandler(pobjUID), name ) == 0 )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 
-  return sciInitEventHandler( pObj, name ) ;
+    return sciInitEventHandler( pobjUID, name ) ;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciInitIsEventHandlerEnable( sciPointObj * pObj, BOOL enable )
-{
-  if(sciGetEntityType( pObj ) == SCI_FIGURE)
-    {
-      sciFigure * ppFigure = pFIGURE_FEATURE(pObj) ;
-      /*
-      ** If we try to enable an empty Event Handler
-      ** raise a Warning.
-      */
-      if (ppFigure != NULL
-         && ppFigure->eventHandler != NULL
-         && (strcmp(ppFigure->eventHandler, "") != 0 || enable == FALSE))
-       {
-         pFIGURE_FEATURE(pObj)->isEventHandlerEnable = enable ;
+int sciInitIsEventHandlerEnable( char * pobjUID, BOOL enable )
+{
+    // FIXME
+    abort();
+#if 0
+        if(sciGetEntityType( pobjUID ) == SCI_FIGURE)
+    {
+        sciFigure * ppFigure = pFIGURE_FEATURE(pobjUID) ;
+        /*
+        ** If we try to enable an empty Event Handler
+        ** raise a Warning.
+        */
+        if (ppFigure != NULL
+            && ppFigure->eventHandler != NULL
+            && (strcmp(ppFigure->eventHandler, "") != 0 || enable == FALSE))
+        {
+            pFIGURE_FEATURE(pobjUID)->isEventHandlerEnable = enable ;
 
-         /* Java is called to enable or disable the listener */
-         if (!isFigureModel(pObj->UID))
-           {
-             setFigureEventHandlerEnabled(sciGetNum(pObj), enable);
-           }
-       }
-      else
-       {
-         Scierror(999, _("%s: Can't enable a void event handler.\n"), "sciInitEventHandler") ;
-       }
-      return 0 ;
+            /* Java is called to enable or disable the listener */
+            if (!isFigureModel(pobjUID))
+            {
+                setFigureEventHandlerEnabled(sciGetNum(pobjUID), enable);
+            }
+        }
+        else
+        {
+            Scierror(999, _("%s: Can't enable a void event handler.\n"), "sciInitEventHandler") ;
+        }
+        return 0 ;
     }
-  else
+    else
     {
-      printSetGetErrorMessage("event_handler");
-      return -1 ;
+        printSetGetErrorMessage("event_handler");
+        return -1 ;
     }
+#endif
+        return -1;
 }
 /*-----------------------------------------------------------------------------------*/
-int sciSetIsEventHandlerEnable( sciPointObj * pObj, BOOL enable )
+int sciSetIsEventHandlerEnable( char * pobjUID, BOOL enable )
 {
-  if ( sciGetIsEventHandlerEnable(pObj) == enable )
-  {
-    /* nothing to do */
-    return 1 ;
-  }
+    if ( sciGetIsEventHandlerEnable(pobjUID) == enable )
+    {
+        /* nothing to do */
+        return 1 ;
+    }
 
-  return sciInitIsEventHandlerEnable( pObj, enable ) ;
+    return sciInitIsEventHandlerEnable( pobjUID, enable ) ;
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * Set data-bounds defined by the user.
  * @param bounds [Xmin,Xmax,Ymain,Ymax,Zmin,Zmax] vector.
  */
-int sciSetDataBounds( sciPointObj * pObj, double bounds[6] )
+int sciSetDataBounds( char * pobjUID, double bounds[6] )
 {
-  int i;
-  switch( sciGetEntityType(pObj) )
-  {
-  case SCI_SUBWIN:
-    for ( i = 0 ; i < 6 ; i++ )
-    {
-      pSUBWIN_FEATURE(pObj)->SRect[i] = bounds[i] ;
-    }
-    return 0;
-  case SCI_SURFACE:
-    for ( i = 0 ; i < 6 ; i++ )
+    // FIXME
+    abort();
+#if 0
+        int i;
+    switch( sciGetEntityType(pobjUID) )
     {
-      pSURFACE_FEATURE(pObj)->ebox[i] = bounds[i] ;
-    }
-    return 0;
-  default:
-    printSetGetErrorMessage("data_bounds");
-    return -1 ;
+    case SCI_SUBWIN:
+        for ( i = 0 ; i < 6 ; i++ )
+        {
+            pSUBWIN_FEATURE(pobjUID)->SRect[i] = bounds[i] ;
+        }
+        return 0;
+    case SCI_SURFACE:
+        for ( i = 0 ; i < 6 ; i++ )
+        {
+            pSURFACE_FEATURE(pobjUID)->ebox[i] = bounds[i] ;
+        }
+        return 0;
+    default:
+        printSetGetErrorMessage("data_bounds");
+        return -1 ;
 
-  }
+    }
+#endif
+    return -1;
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * Set the displayed data bounds of a subwin object.
  */
-int sciSetRealDataBounds(sciPointObj * pObj, const double bounds[6])
+int sciSetRealDataBounds(char * pobjUID, const double bounds[6])
 {
-  int i;
-  switch( sciGetEntityType(pObj) )
-  {
-  case SCI_SUBWIN:
-    for ( i = 0 ; i < 6 ; i++ )
+     // FIXME
+    abort();
+#if 0
+       int i;
+    switch( sciGetEntityType(pobjUID) )
     {
-      pSUBWIN_FEATURE(pObj)->FRect[i] = bounds[i] ;
-    }
-    return 0;
-  default:
-    printSetGetErrorMessage("data_bounds");
-    return -1 ;
+    case SCI_SUBWIN:
+        for ( i = 0 ; i < 6 ; i++ )
+        {
+            pSUBWIN_FEATURE(pobjUID)->FRect[i] = bounds[i] ;
+        }
+        return 0;
+    default:
+        printSetGetErrorMessage("data_bounds");
+        return -1 ;
 
-  }
+    }
+#endif
+    return -1;
 }
 /*--------------------------------------------------------------------------------------------*/
-int sciInitViewingAngles( sciPointObj * pObj, double alpha, double theta)
+int sciInitViewingAngles( char * pobjUID, double alpha, double theta)
 {
-  switch(sciGetEntityType(pObj))
-  {
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pObj)->alpha = alpha;
-    pSUBWIN_FEATURE(pObj)->theta = theta;
-    return 0;
-  default:
-    printSetGetErrorMessage("rotation_angles");
-       return -1;
-  }
-
+     // FIXME
+    abort();
+#if 0
+       switch(sciGetEntityType(pobjUID))
+    {
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->alpha = alpha;
+        pSUBWIN_FEATURE(pobjUID)->theta = theta;
+        return 0;
+    default:
+        printSetGetErrorMessage("rotation_angles");
+        return -1;
+    }
+#endif
+       return -1;
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * Set the viewing angles (in degrees) of a subwindow
  */
-int sciSetViewingAngles( sciPointObj * pObj, double alpha, double theta)
-{
-  double curAlpha;
-  double curTheta;
-  sciGetViewingAngles(pObj, &curAlpha, &curTheta);
-  if ( curAlpha == alpha && curTheta == theta )
-  {
-    /* nothing to do */
-    return 1;
-  }
+int sciSetViewingAngles( char * pobjUID, double alpha, double theta)
+{
+    double curAlpha;
+    double curTheta;
+    sciGetViewingAngles(pobjUID, &curAlpha, &curTheta);
+    if ( curAlpha == alpha && curTheta == theta )
+    {
+        /* nothing to do */
+        return 1;
+    }
 
-  return sciInitViewingAngles(pObj, alpha, theta) ;
+    return sciInitViewingAngles(pobjUID, alpha, theta) ;
 
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * Set the info message of a figure with the information about rotation angles
  */
-int setInfoMessageWithRotationAngles(sciPointObj * pFigure, double alpha, double theta)
+int setInfoMessageWithRotationAngles(char * pFigure, double alpha, double theta)
 {
-  /* keep this lower than 10*/
-  #define ANGLE_DECIMAL_NUMBERS 1
-  char angleDisplayFormat[5];
-  int returnStatus = -1;
-  double intPart;
-  char * infoMessage = NULL;
-  char formatedInfoMessage[29];
+    // FIXME
+    abort();
+#if 0
+        /* keep this lower than 10*/
+#define ANGLE_DECIMAL_NUMBERS 1
+    char angleDisplayFormat[5];
+    int returnStatus = -1;
+    double intPart;
+    char * infoMessage = NULL;
+    char formatedInfoMessage[29];
 
-  /* Size without numbers is 8 for "alpha = ", 10 for ", theta = " and 1 for the null terminating character */
-  int infoMessageSize = 19;
+    /* Size without numbers is 8 for "alpha = ", 10 for ", theta = " and 1 for the null terminating character */
+    int infoMessageSize = 19;
 
-  /* set number of digits so format is %.xf where x is ANGLE_DECIMAL_NUMBERS */
-  sprintf(angleDisplayFormat, "%%.%df", ANGLE_DECIMAL_NUMBERS);
+    /* set number of digits so format is %.xf where x is ANGLE_DECIMAL_NUMBERS */
+    sprintf(angleDisplayFormat, "%%.%df", ANGLE_DECIMAL_NUMBERS);
 
-  /* compute size of alpha wich is the length of its int part plus 1 for the dot */
-  /* and the number of decimals */
-  modf(alpha, &intPart); /* get int part of alpha */
-  infoMessageSize += GET_NB_DIGITS(intPart) + 1 + ANGLE_DECIMAL_NUMBERS;
+    /* compute size of alpha wich is the length of its int part plus 1 for the dot */
+    /* and the number of decimals */
+    modf(alpha, &intPart); /* get int part of alpha */
+    infoMessageSize += GET_NB_DIGITS(intPart) + 1 + ANGLE_DECIMAL_NUMBERS;
 
-  /* same for theta */
-  modf(theta, &intPart);
-  infoMessageSize += GET_NB_DIGITS(intPart) + 1 + ANGLE_DECIMAL_NUMBERS;
+    /* same for theta */
+    modf(theta, &intPart);
+    infoMessageSize += GET_NB_DIGITS(intPart) + 1 + ANGLE_DECIMAL_NUMBERS;
 
-  /* We use also infomessage string to store the formated massage */
-  /* The needed size might be 19 plus twice the format length so 8 => 27 */
+    /* We use also infomessage string to store the formated massage */
+    /* The needed size might be 19 plus twice the format length so 8 => 27 */
 
-  /* Add alpha size, which is the size of its int part plus 1 for the dot and only  */
+    /* Add alpha size, which is the size of its int part plus 1 for the dot and only  */
 
-  infoMessage = MALLOC(infoMessageSize * sizeof(char));
-  if (infoMessage == NULL)
-  {
-    /* no more memory */
-    return -1;
-  }
+    infoMessage = MALLOC(infoMessageSize * sizeof(char));
+    if (infoMessage == NULL)
+    {
+        /* no more memory */
+        return -1;
+    }
 
-  /* Put the formats in the string */
-  sprintf(formatedInfoMessage, "alpha = %s, theta = %s", angleDisplayFormat, angleDisplayFormat);
+    /* Put the formats in the string */
+    sprintf(formatedInfoMessage, "alpha = %s, theta = %s", angleDisplayFormat, angleDisplayFormat);
 
-  /* convert the formats into the angle values */
-  sprintf(infoMessage, formatedInfoMessage, alpha, theta);
+    /* convert the formats into the angle values */
+    sprintf(infoMessage, formatedInfoMessage, alpha, theta);
 
-  returnStatus = sciSetInfoMessage(pFigure, infoMessage) ;
+    returnStatus = sciSetInfoMessage(pFigure, infoMessage) ;
 
-  FREE(infoMessage);
+    FREE(infoMessage);
 
-  return returnStatus;
+    return returnStatus;
 
-  #undef ANGLE_DECIMAL_NUMBERS
+#undef ANGLE_DECIMAL_NUMBERS
+#endif
+    return -1;
 }
 /*-----------------------------------------------------------------------------------*/
 /**
  * To set the pixmap mode of a figure to on or off
  */
-int sciInitPixmapMode(sciPointObj * pObj, BOOL onOrOff)
+int sciInitPixmapMode(char * pobjUID, BOOL onOrOff)
 {
-  switch(sciGetEntityType(pObj))
-  {
-  case SCI_FIGURE:
-    pFIGURE_FEATURE(pObj)->pixmapMode = onOrOff;
-    return 0;
-  default:
-    printSetGetErrorMessage("pixmap");
-       return -1;
-  }
+     // FIXME
+    abort();
+#if 0
+       switch(sciGetEntityType(pobjUID))
+    {
+    case SCI_FIGURE:
+        pFIGURE_FEATURE(pobjUID)->pixmapMode = onOrOff;
+        return 0;
+    default:
+        printSetGetErrorMessage("pixmap");
+        return -1;
+    }
+#endif
+       return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * To set the pixmap mode of a figure to on or off
  */
-int sciSetPixmapMode(sciPointObj * pObj, BOOL onOrOff)
+int sciSetPixmapMode(char * pobjUID, BOOL onOrOff)
 {
-  if (sciGetPixmapMode(pObj) == onOrOff)
-  {
-    /* Nothing to do */
-    return 1;
-  }
-  return sciInitPixmapMode(pObj, onOrOff);
+    if (sciGetPixmapMode(pobjUID) == onOrOff)
+    {
+        /* Nothing to do */
+        return 1;
+    }
+    return sciInitPixmapMode(pobjUID, onOrOff);
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitTextPos( sciPointObj * pObj, double posX, double posY, double posZ)
-{
-  switch(sciGetEntityType(pObj))
-  {
-  case SCI_TEXT:
-    pTEXT_FEATURE(pObj)->x = posX;
-    pTEXT_FEATURE(pObj)->y = posY;
-    pTEXT_FEATURE(pObj)->z = posZ;
-    return 0;
-  case SCI_LABEL:
-    return sciInitTextPos(pLABEL_FEATURE(pObj)->text, posX, posY, posZ);
-  default:
-    printSetGetErrorMessage("data");
-    return -1;
-  }
+int sciInitTextPos( char * pobjUID, double posX, double posY, double posZ)
+{
+    // FIXME
+    abort();
+#if 0
+        switch(sciGetEntityType(pobjUID))
+    {
+    case SCI_TEXT:
+        pTEXT_FEATURE(pobjUID)->x = posX;
+        pTEXT_FEATURE(pobjUID)->y = posY;
+        pTEXT_FEATURE(pobjUID)->z = posZ;
+        return 0;
+    case SCI_LABEL:
+        return sciInitTextPos(pLABEL_FEATURE(pobjUID)->text, posX, posY, posZ);
+    default:
+        printSetGetErrorMessage("data");
+        return -1;
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Set the position of a label or text object.
  */
-int sciSetTextPos( sciPointObj * pObj, double posX, double posY, double posZ)
+int sciSetTextPos( char * pobjUID, double posX, double posY, double posZ)
 {
-  double curPos[3];
-  sciGetTextPos(pObj, curPos);
-  if ( curPos[0] == posX && curPos[1] == posY && curPos[2] == posZ )
-  {
-    /* nothing to do */
-    return 1;
-  }
-  return sciInitTextPos(pObj, posX, posY, posZ);
+    double curPos[3];
+    sciGetTextPos(pobjUID, curPos);
+    if ( curPos[0] == posX && curPos[1] == posY && curPos[2] == posZ )
+    {
+        /* nothing to do */
+        return 1;
+    }
+    return sciInitTextPos(pobjUID, posX, posY, posZ);
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitLogFlags(sciPointObj * pObj, char logFlags[3])
+int sciInitLogFlags(char * pobjUID, char logFlags[3])
 {
-  switch(sciGetEntityType(pObj))
-  {
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pObj)->logflags[0] = logFlags[0];
-    pSUBWIN_FEATURE(pObj)->logflags[1] = logFlags[1];
-    pSUBWIN_FEATURE(pObj)->logflags[2] = logFlags[2];
+    // FIXME
+    abort();
+#if 0
+        switch(sciGetEntityType(pobjUID))
+    {
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->logflags[0] = logFlags[0];
+        pSUBWIN_FEATURE(pobjUID)->logflags[1] = logFlags[1];
+        pSUBWIN_FEATURE(pobjUID)->logflags[2] = logFlags[2];
 
 
 
-    return 0;
-  default:
-    printSetGetErrorMessage("log_flags");
-    return -1;
-  }
+        return 0;
+    default:
+        printSetGetErrorMessage("log_flags");
+        return -1;
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Set the log flags of a subwindow
  */
-int sciSetLogFlags(sciPointObj * pObj, char logFlags[3])
-{
-  char curLogFlags[3];
-  int status;
-  sciGetLogFlags(pObj, curLogFlags);
-  if (   logFlags[0] == curLogFlags[0] && logFlags[1] == curLogFlags[1]
-      && logFlags[2] == curLogFlags[2])
-  {
-    // nothing to do
-    return 1;
-  }
-  status = sciInitLogFlags(pObj, logFlags);
+int sciSetLogFlags(char * pobjUID, char logFlags[3])
+{
+    char curLogFlags[3];
+    int status;
+    sciGetLogFlags(pobjUID, curLogFlags);
+    if (   logFlags[0] == curLogFlags[0] && logFlags[1] == curLogFlags[1]
+           && logFlags[2] == curLogFlags[2])
+    {
+        // nothing to do
+        return 1;
+    }
+    status = sciInitLogFlags(pobjUID, logFlags);
 
-  // force redraw of all children of the object.
-  if (status == 0 && pObj != getAxesModel())
-  {
-    forceHierarchyRedraw(pObj);
-  }
+    // force redraw of all children of the object.
+    if (status == 0 && pobjUID != getAxesModel())
+    {
+        forceHierarchyRedraw(pobjUID);
+    }
 
-  return status;
+    return status;
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitAutoTicks(sciPointObj * pObj, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ)
-{
-  switch(sciGetEntityType(pObj))
-  {
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pObj)->axes.auto_ticks[0] = autoTicksX;
-    pSUBWIN_FEATURE(pObj)->axes.auto_ticks[1] = autoTicksY;
-    pSUBWIN_FEATURE(pObj)->axes.auto_ticks[2] = autoTicksZ;
-    return 0;
-  default:
-    printSetGetErrorMessage("auto_ticks");
-    return -1;
-  }
+int sciInitAutoTicks(char * pobjUID, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ)
+{
+    // FIXME
+    abort();
+#if 0
+        switch(sciGetEntityType(pobjUID))
+    {
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[0] = autoTicksX;
+        pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[1] = autoTicksY;
+        pSUBWIN_FEATURE(pobjUID)->axes.auto_ticks[2] = autoTicksZ;
+        return 0;
+    default:
+        printSetGetErrorMessage("auto_ticks");
+        return -1;
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
-int sciSetAutoTicks(sciPointObj * pObj, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ)
+int sciSetAutoTicks(char * pobjUID, BOOL autoTicksX, BOOL autoTicksY, BOOL autoTicksZ)
 {
-  BOOL curAutoTicks[3];
-  sciGetAutoTicks(pObj, curAutoTicks);
+    BOOL curAutoTicks[3];
+    sciGetAutoTicks(pobjUID, curAutoTicks);
 
-  if (curAutoTicks[0] == autoTicksX && curAutoTicks[1] == autoTicksY && curAutoTicks[2] == autoTicksZ)
-  {
-    // nothing to do
-    return 1;
-  }
+    if (curAutoTicks[0] == autoTicksX && curAutoTicks[1] == autoTicksY && curAutoTicks[2] == autoTicksZ)
+    {
+        // nothing to do
+        return 1;
+    }
 
-  return sciInitAutoTicks(pObj, autoTicksX, autoTicksY, autoTicksZ);
+    return sciInitAutoTicks(pobjUID, autoTicksX, autoTicksY, autoTicksZ);
 
 }
 /*----------------------------------------------------------------------------------*/
@@ -3822,238 +4091,287 @@ int sciSetAutoTicks(sciPointObj * pObj, BOOL autoTicksX, BOOL autoTicksY, BOOL a
  * Specify a new zoom box for a subwin object.
  * @param zoomBox [xMin, xMax, yMin, yMax, zMin, zMax] vector.
  */
-int sciSetZoomBox(sciPointObj * pObj, const double zoomBox[6])
-{
-  switch(sciGetEntityType(pObj))
-  {
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pObj)->ZRect[0] = zoomBox[0];
-    pSUBWIN_FEATURE(pObj)->ZRect[1] = zoomBox[1];
-    pSUBWIN_FEATURE(pObj)->ZRect[2] = zoomBox[2];
-    pSUBWIN_FEATURE(pObj)->ZRect[3] = zoomBox[3];
-    pSUBWIN_FEATURE(pObj)->ZRect[4] = zoomBox[4];
-    pSUBWIN_FEATURE(pObj)->ZRect[5] = zoomBox[5];
-    return 0;
-  default:
-    printSetGetErrorMessage("zoom_box");
-    return -1;
-  }
+int sciSetZoomBox(char * pobjUID, const double zoomBox[6])
+{
+    // FIXME
+    abort();
+#if 0
+        switch(sciGetEntityType(pobjUID))
+    {
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->ZRect[0] = zoomBox[0];
+        pSUBWIN_FEATURE(pobjUID)->ZRect[1] = zoomBox[1];
+        pSUBWIN_FEATURE(pobjUID)->ZRect[2] = zoomBox[2];
+        pSUBWIN_FEATURE(pobjUID)->ZRect[3] = zoomBox[3];
+        pSUBWIN_FEATURE(pobjUID)->ZRect[4] = zoomBox[4];
+        pSUBWIN_FEATURE(pobjUID)->ZRect[5] = zoomBox[5];
+        return 0;
+    default:
+        printSetGetErrorMessage("zoom_box");
+        return -1;
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitImmediateDrawingMode(sciPointObj * pObj, BOOL autoRedraw)
+int sciInitImmediateDrawingMode(char * pobjUID, BOOL autoRedraw)
 {
-  switch(sciGetEntityType(pObj))
-  {
-  case SCI_FIGURE:
-    pFIGURE_FEATURE(pObj)->auto_redraw = autoRedraw;
-    return 0;
-  default:
-    printSetGetErrorMessage("immediate_drawing");
-    return -1;
-  }
+     // FIXME
+    abort();
+#if 0
+       switch(sciGetEntityType(pobjUID))
+    {
+    case SCI_FIGURE:
+        pFIGURE_FEATURE(pobjUID)->auto_redraw = autoRedraw;
+        return 0;
+    default:
+        printSetGetErrorMessage("immediate_drawing");
+        return -1;
+    }
+#endif
+       return -1;
 }
 /*----------------------------------------------------------------------------------*/
-int sciSetImmediateDrawingMode(sciPointObj * pObj, BOOL autoRedraw)
+int sciSetImmediateDrawingMode(char * pobjUID, BOOL autoRedraw)
 {
-  if (sciGetImmediateDrawingMode(pObj) == autoRedraw)
-  {
-    // nothing to do
-    return 1;
-  }
-  return sciInitImmediateDrawingMode(pObj, autoRedraw);
+    // FIXME
+    abort();
+#if 0
+        if (sciGetImmediateDrawingMode(pobjUID) == autoRedraw)
+    {
+        // nothing to do
+        return 1;
+    }
+    return sciInitImmediateDrawingMode(pobjUID, autoRedraw);
+#endif
+    return -1;
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitUseNurbs(sciPointObj * pObj, BOOL useNurbs)
+int sciInitUseNurbs(char * pobjUID, BOOL useNurbs)
 {
-  switch (sciGetEntityType(pObj))
-  {
-  case SCI_SUBWIN:
-    pSUBWIN_FEATURE(pObj)->useNurbsForArcs = useNurbs;
-    return 0;
-  case SCI_ARC:
-    pARC_FEATURE(pObj)->useNurbs = useNurbs;
-    return 0;
-  default:
-    printSetGetErrorMessage("drawing_method");
-    return -1;
-  }
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType(pobjUID))
+    {
+    case SCI_SUBWIN:
+        pSUBWIN_FEATURE(pobjUID)->useNurbsForArcs = useNurbs;
+        return 0;
+    case SCI_ARC:
+        pARC_FEATURE(pobjUID)->useNurbs = useNurbs;
+        return 0;
+    default:
+        printSetGetErrorMessage("drawing_method");
+        return -1;
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Return whether the drawing of an arc object uses nurbs or lines
  */
-int sciSetUseNurbs(sciPointObj * pObj, BOOL useNurbs)
+int sciSetUseNurbs(char * pobjUID, BOOL useNurbs)
 {
-  if (sciGetUseNurbs(pObj) == useNurbs)
-  {
-    // nothing to do
-    return 1;
-  }
-  return sciInitUseNurbs(pObj, useNurbs);
+    if (sciGetUseNurbs(pobjUID) == useNurbs)
+    {
+        // nothing to do
+        return 1;
+    }
+    return sciInitUseNurbs(pobjUID, useNurbs);
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitIsUsingFractionalMetrics(sciPointObj * pObj, BOOL useFractionalMetrics)
+int sciInitIsUsingFractionalMetrics(char * pobjUID, BOOL useFractionalMetrics)
 {
-  sciFont * fontContext = sciGetFontContext(pObj);
-  if (fontContext != NULL)
-  {
-    fontContext->useFractionalMetrics = useFractionalMetrics;
-    return 0;
-  }
-  printSetGetErrorMessage("fractional_font");
-  return -1;
+    // FIXME
+    abort();
+#if 0
+        sciFont * fontContext = sciGetFontContext(pobjUID);
+    if (fontContext != NULL)
+    {
+        fontContext->useFractionalMetrics = useFractionalMetrics;
+        return 0;
+    }
+    printSetGetErrorMessage("fractional_font");
+#endif
+    return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
-* Return whether an arc object uses fractional metrics for text display
-*/
-int sciSetIsUsingFractionalMetrics(sciPointObj * pObj, BOOL useFractionalMetrics)
+ * Return whether an arc object uses fractional metrics for text display
+ */
+int sciSetIsUsingFractionalMetrics(char * pobjUID, BOOL useFractionalMetrics)
 {
-  if (sciGetIsUsingFractionalMetrics(pObj) == useFractionalMetrics)
-  {
-    // nothing to do
-    return 1;
-  }
-  return sciInitIsUsingFractionalMetrics(pObj, useFractionalMetrics);
+    if (sciGetIsUsingFractionalMetrics(pobjUID) == useFractionalMetrics)
+    {
+        // nothing to do
+        return 1;
+    }
+    return sciInitIsUsingFractionalMetrics(pobjUID, useFractionalMetrics);
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitColorRange(sciPointObj * pObj, int subset[2])
+int sciInitColorRange(char * pobjUID, int subset[2])
 {
-  switch (sciGetEntityType(pObj))
-  {
-  case SCI_FEC:
-               pFEC_FEATURE(pObj)->colminmax[0] = subset[0];
-               pFEC_FEATURE(pObj)->colminmax[1] = subset[1];
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType(pobjUID))
+    {
+    case SCI_FEC:
+               pFEC_FEATURE(pobjUID)->colminmax[0] = subset[0];
+               pFEC_FEATURE(pobjUID)->colminmax[1] = subset[1];
                return 0;
-  default:
-    printSetGetErrorMessage("color_range");
+    default:
+        printSetGetErrorMessage("color_range");
                return -1;
-  }
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Modify the subset of colormap bounds used by a particular object (colminmax).
  */
-int sciSetColorRange(sciPointObj * pObj, int subset[2])
+int sciSetColorRange(char * pobjUID, int subset[2])
 {
 
        int curColorRange[2];
-       sciGetColorRange(pObj, curColorRange);
+       sciGetColorRange(pobjUID, curColorRange);
        if (curColorRange[0] == subset[0] && curColorRange[1] == subset[1])
        {
                /* nothing to do */
                return 1;
        }
 
-       return sciInitColorRange(pObj, subset);
+       return sciInitColorRange(pobjUID, subset);
 
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitOutsideColors(sciPointObj * pObj, int colors[2])
+int sciInitOutsideColors(char * pobjUID, int colors[2])
 {
-  switch (sciGetEntityType(pObj))
-  {
-  case SCI_FEC:
-               pFEC_FEATURE(pObj)->colout[0] = colors[0];
-               pFEC_FEATURE(pObj)->colout[1] = colors[1];
+     // FIXME
+    abort();
+#if 0
+       switch (sciGetEntityType(pobjUID))
+    {
+    case SCI_FEC:
+               pFEC_FEATURE(pobjUID)->colout[0] = colors[0];
+               pFEC_FEATURE(pobjUID)->colout[1] = colors[1];
                return 0;
-  default:
-    printSetGetErrorMessage("outside_color");
+    default:
+        printSetGetErrorMessage("outside_color");
                return -1;
-  }
+    }
+#endif
+       return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Modify the color to use for an objects when it uses index outside of the colormap (colout).
  */
-int sciSetOutsideColors(sciPointObj * pObj, int colors[2])
+int sciSetOutsideColors(char * pobjUID, int colors[2])
 {
 
        int curColors[2];
-       sciGetOutsideColor(pObj, curColors);
+       sciGetOutsideColor(pobjUID, curColors);
        if (curColors[0] == colors[0] && curColors[1] == colors[1])
        {
                /* nothing to do */
                return 1;
        }
 
-  return sciInitOutsideColors(pObj, colors);
+    return sciInitOutsideColors(pobjUID, colors);
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitZBounds(sciPointObj * pObj, double bounds[2])
+int sciInitZBounds(char * pobjUID, double bounds[2])
 {
-  switch (sciGetEntityType(pObj))
-  {
-  case SCI_FEC:
-               pFEC_FEATURE(pObj)->zminmax[0] = bounds[0];
-               pFEC_FEATURE(pObj)->zminmax[1] = bounds[1];
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType(pobjUID))
+    {
+    case SCI_FEC:
+               pFEC_FEATURE(pobjUID)->zminmax[0] = bounds[0];
+               pFEC_FEATURE(pobjUID)->zminmax[1] = bounds[1];
                return 0;
-  default:
-    printSetGetErrorMessage("z_bounds");
+    default:
+        printSetGetErrorMessage("z_bounds");
                return -1;
-  }
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Modify the Z range used by a fec object (zminmax).
  */
-int sciSetZBounds(sciPointObj * pObj, double bounds[2])
+int sciSetZBounds(char * pobjUID, double bounds[2])
 {
-  double curBounds[2];
-       sciGetZBounds(pObj, curBounds);
+    double curBounds[2];
+       sciGetZBounds(pobjUID, curBounds);
        if (curBounds[0] == bounds[0] && curBounds[1] == bounds[1])
        {
                /* nothing to do */
                return 1;
        }
 
-       return sciInitZBounds(pObj, bounds);
+       return sciInitZBounds(pobjUID, bounds);
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitGridFront(sciPointObj * pObj, BOOL gridFront)
+int sciInitGridFront(char * pobjUID, BOOL gridFront)
 {
-  switch (sciGetEntityType(pObj))
-  {
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType(pobjUID))
+    {
        case SCI_SUBWIN:
-               pSUBWIN_FEATURE(pObj)->gridFront = gridFront;
+               pSUBWIN_FEATURE(pobjUID)->gridFront = gridFront;
                return 0;
        default:
-    printSetGetErrorMessage("grid_position");
+        printSetGetErrorMessage("grid_position");
                return -1;
-  }
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Modify whether the grid is drawn in background or foreground.
  */
-int sciSetGridFront(sciPointObj * pObj, BOOL gridFront)
+int sciSetGridFront(char * pobjUID, BOOL gridFront)
 {
-       if (sciGetGridFront(pObj) == gridFront)
+       if (sciGetGridFront(pobjUID) == gridFront)
        {
                /* nothing to do */
                return 1;
        }
-       return sciInitGridFront(pObj, gridFront);
+       return sciInitGridFront(pobjUID, gridFront);
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitAntialiasingQuality(sciPointObj * pObj, int quality)
+int sciInitAntialiasingQuality(char * pobjUID, int quality)
 {
-  switch (sciGetEntityType(pObj))
-  {
+    // FIXME
+    abort();
+#if 0
+        switch (sciGetEntityType(pobjUID))
+    {
        case SCI_FIGURE:
-               if (isFigureModel(pObj->UID))
+               if (isFigureModel(pobjUID))
                {
-                       pFIGURE_FEATURE(pObj)->pModelData->antialiasingQuality = quality;
+                       pFIGURE_FEATURE(pobjUID)->pModelData->antialiasingQuality = quality;
                }
                else
                {
-                       sciSetJavaAntialiasingQuality(pObj, quality);
+                       sciSetJavaAntialiasingQuality(pobjUID, quality);
                }
                return 0;
-  default:
-    printSetGetErrorMessage("anti_aliasing");
+    default:
+        printSetGetErrorMessage("anti_aliasing");
                return -1;
-  }
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
@@ -4063,48 +4381,53 @@ int sciInitAntialiasingQuality(sciPointObj * pObj, int quality)
  * specifies the number of pass for antialiasing.
  * @param quality positive integer.
  */
-int sciSetAntialiasingQuality(sciPointObj * pObj, int quality)
+int sciSetAntialiasingQuality(char * pobjUID, int quality)
 {
-  if (sciGetAntialiasingQuality(pObj) == quality)
+    if (sciGetAntialiasingQuality(pobjUID) == quality)
        {
                /* nothing to do */
                return 1;
        }
-       return sciInitAntialiasingQuality(pObj, quality);
+       return sciInitAntialiasingQuality(pobjUID, quality);
 }
 /*----------------------------------------------------------------------------------*/
-int sciInitLegendLocation(sciPointObj * pObj, sciLegendPlace location)
+int sciInitLegendLocation(char * pobjUID, sciLegendPlace location)
 {
-       switch (sciGetEntityType(pObj))
-  {
+    // FIXME
+    abort();
+#if 0
+       switch (sciGetEntityType(pobjUID))
+    {
        case SCI_LEGEND:
-               pLEGEND_FEATURE(pObj)->place = location;
+               pLEGEND_FEATURE(pobjUID)->place = location;
                return 0;
        default:
-    printSetGetErrorMessage("legend_location");
+        printSetGetErrorMessage("legend_location");
                return -1;
-  }
+    }
+#endif
+        return -1;
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Modify the legend position relatively to the subwindow
  */
-int sciSetLegendLocation(sciPointObj * pObj, sciLegendPlace location)
+int sciSetLegendLocation(char * pobjUID, sciLegendPlace location)
 {
-       if (sciGetLegendLocation(pObj) == location)
+       if (sciGetLegendLocation(pobjUID) == location)
        {
                /* nothing to do */
                return 1;
        }
-       return sciInitLegendLocation(pObj, location);
+       return sciInitLegendLocation(pobjUID, location);
 }
 /*----------------------------------------------------------------------------------*/
 /**
  * Check that a color index is within the colormap range or not
- * @param pObj object conatining the color
+ * @param pobjUID object conatining the color
  */
-BOOL sciCheckColorIndex(sciPointObj * pObj, int colorIndex)
+BOOL sciCheckColorIndex(char * pobjUID, int colorIndex)
 {
-  return (colorIndex >= -2) && (colorIndex <= sciGetNumColors(pObj) + 2);
+    return (colorIndex >= -2) && (colorIndex <= sciGetNumColors(pobjUID) + 2);
 }
 /*----------------------------------------------------------------------------------*/
index cef0c08..13eb14a 100644 (file)
@@ -251,7 +251,7 @@ SetPropertyHashTable * createScilabSetHashTable( void )
 
 }
 /*--------------------------------------------------------------------------*/
-int callSetProperty( sciPointObj * pObj, size_t stackPointer, int valueType, int nbRow, int nbCol, char * propertyName )
+int callSetProperty(char* pObjUID, size_t stackPointer, int valueType, int nbRow, int nbCol, char * propertyName )
 {
  setPropertyFunc accessor = searchSetHashtable( setHashTable, propertyName ) ;
   if ( accessor == NULL )
@@ -259,7 +259,7 @@ int callSetProperty( sciPointObj * pObj, size_t stackPointer, int valueType, int
     Scierror(999,_("Unknown property: %s.\n"), propertyName ) ;
     return -1 ;
   }
-  return accessor( pObj, stackPointer, valueType, nbRow, nbCol ) ;
+  return accessor(pObjUID, stackPointer, valueType, nbRow, nbCol ) ;
 }
 /*--------------------------------------------------------------------------*/
 void destroyScilabSetHashTable( void )
index 82aaf66..48e3059 100644 (file)
@@ -1,11 +1,12 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
@@ -20,7 +21,6 @@
 
 #include "dynlib_graphics.h"
 #include "setGetHashTable.h"
-#include "ObjectStructure.h"
 
 /**
  * create the fill hash table already filled for set functions
@@ -33,12 +33,12 @@ GRAPHICS_IMPEXP SetPropertyHashTable * createScilabSetHashTable( void ) ;
  */
 GRAPHICS_IMPEXP void destroyScilabSetHashTable( void ) ;
 
-/** 
+/**
  * call the function which the property propertyName of object pObj
  * @return  0 if successful
  *         -1 if an error occured in the get function
  *          1 if the property was not found
  */
-GRAPHICS_IMPEXP int callSetProperty( sciPointObj * pObj, size_t stackPointer, int valueType, int nbRow, int nbCol, char * propertyName ) ;
+GRAPHICS_IMPEXP int callSetProperty(char *pObjUID, size_t stackPointer, int valueType, int nbRow, int nbCol, char * propertyName ) ;
 
 #endif /* _SET_HASH_TABLE_H_ */
index c7a2ad1..9b2eef9 100644 (file)
@@ -37,6 +37,8 @@
 #include "callJoGLView.h"
 
 #include "CurrentFigure.h"
+#include "CurrentObject.h"
+#include "CurrentSubwin.h"
 #include "FigureModel.h"
 #include "AxesModel.h"
 #include "HandleManagement.h"
@@ -100,6 +102,7 @@ int get_current_figure_property(char *pobjUID)
          */
         //sciAddNewHandle(newaxesUID);
         setCurrentObject(newaxesUID);
+        setCurrentSubWin(newaxesUID);
 
     }
 
index 5cbfe7f..42e546f 100644 (file)
@@ -1,11 +1,12 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
@@ -24,7 +25,7 @@
 #include "hashtable.h"
 #include "ObjectStructure.h"
 
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /**
  * Hide the real type of hashtable
  */
@@ -34,9 +35,9 @@ typedef struct hashtable GetPropertyHashTable ;
 * Hide the real type of hashtable
 */
 typedef struct hashtable SetPropertyHashTable ;
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /**
  * Prototype of functions used to get a specific property of an handle.
  * The sciPointObj is the object to get the property from
@@ -51,7 +52,7 @@ typedef int (*getPropertyFunc)(char *) ;
 * SET_PROPERTY_UNCHANGED if nothing was actually changed and SET_PROPERTY_ERROR if
 * an error occurred.
 */
-typedef int (*setPropertyFunc)(sciPointObj *, size_t, int, int, int ) ;
+typedef int (*setPropertyFunc)(char *, size_t, int, int, int ) ;
 /*--------------------------------------------------------------------------*/
 
 /*--------------------------------------------------------------------------*/
@@ -98,6 +99,6 @@ setPropertyFunc searchSetHashtable( SetPropertyHashTable * hashTable , char * ke
 */
 int insertSetHashtable( SetPropertyHashTable * hashTable, char * key, setPropertyFunc value ) ;
 
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 
 #endif /* _SET_GET_HASHTABLE_H_ */
index 289e0fc..5b760d2 100644 (file)
@@ -2,11 +2,12 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
  * Copyright (C) 2007 - INRIA - Vicent Couvert
- * 
+ * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
 #ifndef _SET_HANDLE_PROPERTY_H_
 #define _SET_HANDLE_PROPERTY_H_
 
-#include <stdlib.h>
-
-#include "ObjectStructure.h"
-
 #include "SetUimenuLabel.h"
 #include "SetUicontrolString.h"
 #include "SetUicontrolBackgroundColor.h"
 #include "SetUimenuChecked.h"
 
 
-int set_color_map_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_old_style_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_figure_style_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_pixel_drawing_mode_property(   sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_default_values_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_visible_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_auto_resize_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_current_entity_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_current_axes_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_current_figure_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_axes_size_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_figure_position_property(      sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_figure_name_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_figure_size_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_figure_id_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_rotation_style_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_immediate_drawing_property(    sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_pixmap_property(               sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_background_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_interp_color_vector_property(  sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_interp_color_mode_property(    sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_foreground_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_fill_mode_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_thickness_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_arrow_size_factor_property(    sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_line_style_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_line_mode_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_surface_mode_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_mark_style_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_mark_mode_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_mark_size_unit_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_mark_size_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_mark_foreground_property(      sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_mark_background_property(      sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_bar_width_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_bar_layout_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_x_shift_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_y_shift_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_z_shift_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_polyline_style_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_font_size_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_font_angle_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_font_foreground_property(      sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_font_color_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_font_style_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_text_box_mode_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_auto_dimensionning_property(   sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_alignment_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_text_box_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_text_property(                 sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_auto_clear_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_auto_scale_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_zoom_box_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_zoom_state_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_clip_box_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_clip_state_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_data_property(                 sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_x_label_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_y_label_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_z_label_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_callbackmevent_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_callback_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_title_property(                sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_tics_direction_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_x_location_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_y_location_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_tight_limits_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_closed_property(               sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_auto_position_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_auto_rotation_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_position_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_auto_ticks_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_axes_reverse_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_view_property(                 sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_axes_bounds_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_data_bounds_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_margins_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_tics_color_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_tics_style_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_sub_tics_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_format_n_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_tics_segment_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_labels_font_size_property(     sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_labels_font_color_property(    sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_labels_font_style_property(    sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_tics_labels_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_xtics_coord_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_ytics_coord_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_box_property(                  sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_grid_property(                 sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_axes_visible_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_hidden_color_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_isoview_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_cube_scaling_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_log_flags_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_arrow_size_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_segs_color_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_colored_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_data_mapping_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_rotation_angles_property(      sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_color_mode_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_color_flag_property(           sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_cdata_mapping_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_surface_color_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_triangles_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_z_bounds_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_handle_visible_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_callback_type_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_hidden_axis_color_property(    sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_user_data_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_x_ticks_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_y_ticks_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_z_ticks_property(              sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_parent_property(               sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_children_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_viewport_property(             sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_info_message_property(         sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_screen_position_property(      sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_dimension_property(            sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_event_handler_enable_property( sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_event_handler_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_arc_drawing_method_property(   sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_fractional_font_property(      sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_links_property(                sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_legend_location_property(      sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_filled_property(               sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_outside_colors_property(       sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_color_range_property(          sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_grid_position_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_anti_aliasing_property(        sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
-int set_tag_property(                  sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_color_map_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_old_style_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_figure_style_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_pixel_drawing_mode_property(   char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_default_values_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_visible_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_auto_resize_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_current_entity_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_current_axes_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_current_figure_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_axes_size_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_figure_position_property(      char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_figure_name_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_figure_size_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_figure_id_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_rotation_style_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_immediate_drawing_property(    char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_pixmap_property(               char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_background_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_interp_color_vector_property(  char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_interp_color_mode_property(    char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_foreground_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_fill_mode_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_thickness_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_arrow_size_factor_property(    char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_line_style_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_line_mode_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_surface_mode_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_mark_style_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_mark_mode_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_mark_size_unit_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_mark_size_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_mark_foreground_property(      char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_mark_background_property(      char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_bar_width_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_bar_layout_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_x_shift_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_y_shift_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_z_shift_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_polyline_style_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_font_size_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_font_angle_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_font_foreground_property(      char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_font_color_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_font_style_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_text_box_mode_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_auto_dimensionning_property(   char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_alignment_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_text_box_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_text_property(                 char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_auto_clear_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_auto_scale_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_zoom_box_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_zoom_state_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_clip_box_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_clip_state_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_data_property(                 char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_x_label_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_y_label_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_z_label_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_callbackmevent_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_callback_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_title_property(                char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_tics_direction_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_x_location_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_y_location_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_tight_limits_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_closed_property(               char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_auto_position_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_auto_rotation_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_position_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_auto_ticks_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_axes_reverse_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_view_property(                 char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_axes_bounds_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_data_bounds_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_margins_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_tics_color_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_tics_style_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_sub_tics_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_format_n_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_tics_segment_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_labels_font_size_property(     char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_labels_font_color_property(    char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_labels_font_style_property(    char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_tics_labels_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_xtics_coord_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_ytics_coord_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_box_property(                  char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_grid_property(                 char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_axes_visible_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_hidden_color_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_isoview_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_cube_scaling_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_log_flags_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_arrow_size_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_segs_color_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_colored_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_data_mapping_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_rotation_angles_property(      char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_color_mode_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_color_flag_property(           char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_cdata_mapping_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_surface_color_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_triangles_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_z_bounds_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_handle_visible_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_callback_type_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_hidden_axis_color_property(    char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_user_data_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_x_ticks_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_y_ticks_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_z_ticks_property(              char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_parent_property(               char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_children_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_viewport_property(             char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_info_message_property(         char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_screen_position_property(      char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_dimension_property(            char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_event_handler_enable_property( char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_event_handler_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_arc_drawing_method_property(   char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_fractional_font_property(      char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_links_property(                char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_legend_location_property(      char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_filled_property(               char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_outside_colors_property(       char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_color_range_property(          char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_grid_position_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_anti_aliasing_property(        char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
+int set_tag_property(                  char* pobj, size_t stackPointer, int valueType, int nbRow, int nbCol ) ;
 
 #endif /* _SET_HANDLE_PROPERTY_H_ */
index 931b5fb..aa99e7d 100644 (file)
@@ -30,7 +30,7 @@
 #include "graphicObjectProperties.h"
 
 /*------------------------------------------------------------------------*/
-int set_alignment_property( sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol )
+int set_alignment_property(char* pobjUID, size_t stackPointer, int valueType, int nbRow, int nbCol )
 {
     BOOL status;
     int alignment;
@@ -67,7 +67,7 @@ int set_alignment_property( sciPointObj * pobj, size_t stackPointer, int valueTy
         return SET_PROPERTY_ERROR ;
     }
 
-    status = setGraphicObjectProperty(pobj->UID, __GO_ALIGNMENT__, &alignment, jni_int, 1);
+    status = setGraphicObjectProperty(pobjUID, __GO_ALIGNMENT__, &alignment, jni_int, 1);
 
     if (status == TRUE)
     {
index c3275b9..c57092f 100644 (file)
@@ -5,11 +5,11 @@
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
  * Copyright (C) 2009 - DIGITEO - Pierre Lando
  * Copyright (C) 2010 - DIGITEO - Manuel Juliachs
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
@@ -32,7 +32,7 @@
 #include "graphicObjectProperties.h"
 
 /*------------------------------------------------------------------------*/
-int set_anti_aliasing_property( sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol )
+int set_anti_aliasing_property(char* pobjUID, size_t stackPointer, int valueType, int nbRow, int nbCol )
 {
 
   int quality = 0;
@@ -78,7 +78,7 @@ int set_anti_aliasing_property( sciPointObj * pobj, size_t stackPointer, int val
     return SET_PROPERTY_ERROR ;
   }
 
-  status = setGraphicObjectProperty(pobj->UID, __GO_ANTIALIASING__, &quality, jni_int, 1);
+  status = setGraphicObjectProperty(pobjUID, __GO_ANTIALIASING__, &quality, jni_int, 1);
 
   if (status == TRUE)
   {
index 7647176..615aa2a 100644 (file)
@@ -3,11 +3,11 @@
  * Copyright (C) 2008 - INRIA - Jean-Baptiste Silvy
  * Copyright (C) 2009 - DIGITEO - Pierre Lando
  * Copyright (C) 2010 - DIGITEO - Manuel Juliachs
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
@@ -30,7 +30,7 @@
 #include "graphicObjectProperties.h"
 
 /*------------------------------------------------------------------------*/
-int set_arc_drawing_method_property( sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol )
+int set_arc_drawing_method_property(char* pobjUID, size_t stackPointer, int valueType, int nbRow, int nbCol )
 {
     BOOL status;
     int arcDrawingMethod;
@@ -63,7 +63,7 @@ int set_arc_drawing_method_property( sciPointObj * pobj, size_t stackPointer, in
         return SET_PROPERTY_ERROR;
     }
 
-    status = setGraphicObjectProperty(pobj->UID, __GO_ARC_DRAWING_METHOD__, &arcDrawingMethod, jni_int, 1);
+    status = setGraphicObjectProperty(pobjUID, __GO_ARC_DRAWING_METHOD__, &arcDrawingMethod, jni_int, 1);
 
     if (status == TRUE)
     {
index 6adbee3..46b44a4 100644 (file)
@@ -5,11 +5,11 @@
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
  * Copyright (C) 2009 - DIGITEO - Pierre Lando
  * Copyright (C) 2010 - DIGITEO - Manuel Juliachs
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
@@ -32,7 +32,7 @@
 #include "graphicObjectProperties.h"
 
 /*------------------------------------------------------------------------*/
-int set_arrow_size_factor_property( sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol )
+int set_arrow_size_factor_property(char* pobjUID, size_t stackPointer, int valueType, int nbRow, int nbCol )
 {
     BOOL status;
     double arrowSizeFactor;
@@ -53,7 +53,7 @@ int set_arrow_size_factor_property( sciPointObj * pobj, size_t stackPointer, int
 
     arrowSizeFactor = getDoubleFromStack(stackPointer);
 
-    status = setGraphicObjectProperty(pobj->UID, __GO_ARROW_SIZE_FACTOR__, &arrowSizeFactor, jni_double, 1);
+    status = setGraphicObjectProperty(pobjUID, __GO_ARROW_SIZE_FACTOR__, &arrowSizeFactor, jni_double, 1);
 
     if (status == TRUE)
     {
index 1d4d26a..0bb72c1 100644 (file)
@@ -5,11 +5,11 @@
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
  * Copyright (C) 2009 - DIGITEO - Pierre Lando
  * Copyright (C) 2011 - DIGITEO - Manuel Juliachs
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
@@ -32,7 +32,7 @@
 #include "graphicObjectProperties.h"
 
 /*------------------------------------------------------------------------*/
-int set_arrow_size_property( sciPointObj * pobj, size_t stackPointer, int valueType, int nbRow, int nbCol )
+int set_arrow_size_property(char* pobjUID, size_t stackPointer, int valueType, int nbRow, int nbCol )
 {
     BOOL status;
     double arrowSize;
@@ -53,7