Scicos blocks: use the new MVC graphic for scopes
[scilab.git] / scilab / modules / graphics / src / nographics / nographics.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007 - INRIA - Allan Cornet
4  * Copyright (C) 2008 - INRIA - Vincent COUVERT
5  * Copyright (C) 2009 - DIGITEO - Allan CORNET
6  * Copyright (C) 2010 - DIGITEO - Manuel Juliachs
7  *
8  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at
12  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
13  *
14  */
15 /*--------------------------------------------------------------------------*/
16 #include <string.h>
17 #include "gw_graphics.h"
18 #include "stack-c.h"
19 #include "callFunctionFromGateway.h"
20 #include "graphicModuleLoad.h"
21 #include "TerminateGraphics.h"
22 #include "getDictionaryGetProperties.h"
23 #include "getDictionarySetProperties.h"
24 #include "DrawObjects.h"
25 #include "ObjectSelection.h"
26 #include "GetProperty.h"
27 #include "SetProperty.h"
28 #include "math_graphics.h"
29 #include "DestroyObjects.h"
30 #include "axesScale.h"
31 #include "BuildObjects.h"
32 #include "BasicAlgos.h"
33 #include "pixel_mode.h"
34 #include "Axes.h"
35 #include "getPropertyAssignedValue.h"
36 #include "SetHashTable.h"
37 #include "Scierror.h"
38 #include "localization.h"
39 #include "Format.h"
40 #include "MALLOC.h"
41 #include "Interaction.h"
42 #include "InitObjects.h"
43 #include "ObjectStructure.h"
44
45 /*--------------------------------------------------------------------------*/
46
47 /*
48   We need to add "manually" the functions set, get and delete because
49   if the module graphics is not loaded and because set, get and delete
50   are essentially functions from the graphics module, they will not be
51   available in NWNI mode and if Scilab has been compiled with the flag
52   --without-gui.
53 */
54
55 #define DELETE_INDEX 62
56 #define GET_INDEX    63
57 #define SET_INDEX    64
58
59 int gw_graphics(void)
60 {
61   Rhs = Max(0, Rhs);
62
63   if ( (Fin==DELETE_INDEX || Fin==GET_INDEX || Fin==SET_INDEX) &&
64        (VarType(1)==sci_tlist || VarType(1)==sci_mlist))
65     {
66       int lw = 1 + Top - Rhs;
67       if (Fin==DELETE_INDEX) C2F(overload)(&lw,"delete",6);
68       if (Fin==GET_INDEX) C2F(overload)(&lw,"get",3);
69       if (Fin==SET_INDEX) C2F(overload)(&lw,"set",3);
70     }
71   else
72     {
73       Scierror(999,_("Scilab Graphics module not installed.\n"));
74     }
75   return 0;
76 }
77
78 /*--------------------------------------------------------------------------*/
79 void loadGraphicModule( void )
80 {
81
82 }
83 /*--------------------------------------------------------------------------*/
84 BOOL TerminateGraphics(void)
85 {
86         return TRUE;
87 }
88 /*--------------------------------------------------------------------------*/
89 int sciSetViewport(  char * pObj, const int viewport[4] )
90 {
91         return 0;
92 }
93 /*--------------------------------------------------------------------------*/
94 void sciGetViewport( sciPointObj * pObj, int viewport[4] )
95 {
96
97 }
98 /*--------------------------------------------------------------------------*/
99 double Maxi(const double vect[], int n)
100 {
101         return 0.0;
102 }
103 /*--------------------------------------------------------------------------*/
104 double Mini(const double vect[], int n)
105 {
106         return 0.0;
107 }
108 /*--------------------------------------------------------------------------*/
109 BOOL sciHasFigures( void )
110 {
111   return FALSE;
112 }
113 /*--------------------------------------------------------------------------*/
114 char **getDictionaryGetProperties(int *sizearray)
115 {
116         return NULL;
117 }
118 /*--------------------------------------------------------------------------*/
119 char **getDictionarySetProperties(int *sizearray)
120 {
121         return NULL;
122 }
123 /*--------------------------------------------------------------------------*/
124 int sciGetHeight (sciPointObj * pobj)
125 {
126         return -1;
127 }
128 /*--------------------------------------------------------------------------*/
129 int sciGetNum (sciPointObj * pobj)
130 {
131         return -1;
132 }
133 /*--------------------------------------------------------------------------*/
134 BOOL sciAddThisToItsParent (sciPointObj * pthis, sciPointObj * pparent)
135 {
136         return FALSE ;
137 }
138 /*--------------------------------------------------------------------------*/
139 sciPointObj * sciGetCurrentFigure( void )
140 {
141         return NULL;
142 }
143 /*--------------------------------------------------------------------------*/
144 int sciAddNewHandle (sciPointObj * pobj)
145 {
146         return -1;
147 }
148 /*--------------------------------------------------------------------------*/
149 void createDefaultRelationShip(sciPointObj * pObj)
150 {
151
152 }
153 /*--------------------------------------------------------------------------*/
154 int sciSetEntityType (char* pobj, sciEntityType value)
155 {
156         return -1 ;
157 }
158 /*--------------------------------------------------------------------------*/
159 sciPointObj * sciStandardBuildOperations( sciPointObj * pObj, sciPointObj * parent )
160 {
161         return NULL;
162 }
163 /*--------------------------------------------------------------------------*/
164 void sciInitSelectedSons(sciPointObj * pObj )
165 {
166
167 }
168 /*--------------------------------------------------------------------------*/
169 sciPointObj *sciGetParent (sciPointObj * pobj)
170 {
171         return NULL;
172 }
173 /*--------------------------------------------------------------------------*/
174 sciPointObj *sciGetPointerFromHandle (long handle)
175 {
176         return NULL;
177 }
178 /*--------------------------------------------------------------------------*/
179 unsigned long getHandleFromStack( size_t stackPointer )
180 {
181         return  (unsigned long)(-1);
182 }
183 /*--------------------------------------------------------------------------*/
184 int callSetProperty(char * pObj, size_t stackPointer, int valueType, int nbRow, int nbCol, char * propertyName )
185 {
186         return -1;
187 }
188 /*--------------------------------------------------------------------------*/
189 sciEntityType sciGetEntityType (sciPointObj * pobj)
190 {
191         return (sciEntityType)0;
192 }
193 /*--------------------------------------------------------------------------*/
194 int sciStandardDestroyOperations( sciPointObj * pThis )
195 {
196         return -1;
197 }
198 /*--------------------------------------------------------------------------*/
199 sciPointObj *sciGetParentFigure (sciPointObj * pobj)
200 {
201         return NULL;
202 }
203 /*--------------------------------------------------------------------------*/
204 int sciGetWidth (sciPointObj * pobj)
205 {
206         return 0;
207 }
208 /*--------------------------------------------------------------------------*/
209 int sciSetDimension(  char * pobj, int newWidth, int newHeight )
210 {
211         return -1 ;
212 }
213 /*--------------------------------------------------------------------------*/
214 int sciInitScreenPosition(char * pobj, int pposx, int pposy)
215 {
216         return -1;
217 }
218 /*--------------------------------------------------------------------------*/
219 BOOL sciDelThisToItsParent (sciPointObj * pthis, sciPointObj * pparent)
220 {
221         return FALSE;
222 }
223 /*--------------------------------------------------------------------------*/
224 char * getStringFromStack( size_t stackPointer )
225 {
226         return NULL;
227 }
228 /*--------------------------------------------------------------------------*/
229 double * getDoubleMatrixFromStack( size_t stackPointer )
230 {
231         return NULL;
232 }
233 /*--------------------------------------------------------------------------*/
234 double getDoubleFromStack( size_t stackPointer )
235 {
236         return 0.;
237 }
238 /*--------------------------------------------------------------------------*/
239 char * getFigureFromIndex(int figNum)
240 {
241         return NULL;
242 }
243 /*--------------------------------------------------------------------------*/
244 char ** getStringMatrixFromStack( size_t stackPointer )
245 {
246         return NULL;
247 }
248 /*--------------------------------------------------------------------------*/
249 sciPointObj *sciGetPointerFromJavaIndex (int javaIndex)
250 {
251         return NULL;
252 }
253 /*--------------------------------------------------------------------------*/
254 long sciGetHandle (sciPointObj * pobj)
255 {
256         return (long)0;
257 }
258 /*--------------------------------------------------------------------------*/
259 int sciInitForeground( char * pobj, int colorindex )
260 {
261         return -1;
262 }
263 /*--------------------------------------------------------------------------*/
264 int sciInitFontForeground(char * pobj, int colorindex )
265 {
266         return -1;
267 }
268 /*--------------------------------------------------------------------------*/
269 int sciGetFontForeground (sciPointObj * pobj)
270 {
271         return -1;
272 }
273 /*--------------------------------------------------------------------------*/
274 int sciInitFontSize(char * pobj, double fontSize)
275 {
276         return -1;
277 }
278 /*--------------------------------------------------------------------------*/
279 char * allocateText( char        * pparentsubwinUID,
280                                                                                    char             ** text          ,
281                                                                                    int                 nbRow         ,
282                                                                                    int                 nbCol         ,
283                                                                                    double              x             ,
284                                                                                    double              y             ,
285                                                                                    BOOL                autoSize      ,
286                                                                                    double              userSize[2]   ,
287                                                                                    BOOL                centerPos     ,
288                                                                                    int               * foreground    ,
289                                                                                    int               * background    ,
290                                                                                    BOOL                isboxed       ,
291                                                                                    BOOL                isline        ,
292                                                                                    BOOL                isfilled      ,
293                                                                                    sciTextAlignment    align          )
294 {
295     return NULL;
296 }
297 /*--------------------------------------------------------------------------*/
298 int sciGetForeground (sciPointObj * pobj)
299 {
300         return -1;
301 }
302 /*--------------------------------------------------------------------------*/
303 int sciGetBackground (sciPointObj * pobj)
304 {
305         return -1;
306 }
307 /*--------------------------------------------------------------------------*/
308 int sciInitIsFilled(char * pobj, BOOL isfilled)
309 {
310         return -1;
311 }
312 /*--------------------------------------------------------------------------*/
313 int sciInitIsLine(char * pobj, BOOL isline)
314 {
315         return -1;
316 }
317 /*--------------------------------------------------------------------------*/
318 int sciInitLineStyle( char * pobj, int linestyle )
319 {
320         return -1;
321 }
322 /*--------------------------------------------------------------------------*/
323 int sciInitLineWidth( char * pobj, double linewidth )
324 {
325         return -1;
326 }
327 /*--------------------------------------------------------------------------*/
328 int sciInitBackground( char * pobj, int colorindex )
329 {
330         return -1;
331 }
332 /*--------------------------------------------------------------------------*/
333 int sciInitMarkStyle(char * pobj, int markstyle)
334 {
335         return -1;
336 }
337 /*--------------------------------------------------------------------------*/
338 int sciInitIsMark(char * pobj, BOOL ismark)
339 {
340         return -1;
341 }
342 /*--------------------------------------------------------------------------*/
343 int sciInitMarkBackground(char * pobj, int colorindex)
344 {
345         return -1;
346 }
347 /*--------------------------------------------------------------------------*/
348 int sciGetMarkBackground (sciPointObj * pobj)
349 {
350         return -1;
351 }
352 /*--------------------------------------------------------------------------*/
353 int sciInitMarkForeground(char * pobj, int colorindex)
354 {
355         return -1;
356 }
357 /*--------------------------------------------------------------------------*/
358 int sciGetMarkForeground (sciPointObj * pobj)
359 {
360         return -1;
361 }
362 /*--------------------------------------------------------------------------*/
363 int sciInitMarkSizeUnit(char * pobj, int marksizeunit)
364 {
365         return -1;
366 }
367 /*--------------------------------------------------------------------------*/
368 int sciGetNbTypedObjects( sciPointObj * pObj, sciEntityType type )
369 {
370         return -1;
371 }
372 /*--------------------------------------------------------------------------*/
373 int sciInitArrowSize( char * pobj, double size )
374 {
375         return -1;
376 }
377 /*--------------------------------------------------------------------------*/
378 int sciInitPolylineStyle( char * pobj, int plot )
379 {
380         return -1;
381 }
382 /*--------------------------------------------------------------------------*/
383 int sciGetNumColors (char *pobjUID)
384 {
385         return -1;
386 }
387 /*--------------------------------------------------------------------------*/
388 int deallocateText( sciPointObj * pthis )
389 {
390         return -1;
391 }
392 /*--------------------------------------------------------------------------*/
393 int sciInitFontBackground(char * pobj, int color)
394 {
395         return -1;
396 }
397 /*--------------------------------------------------------------------------*/
398 void sciGetLegendPos (sciPointObj * pobj, double position[2])
399 {
400
401 }
402 /*--------------------------------------------------------------------------*/
403 char sciGetxLocation(sciPointObj * pObj)
404 {
405         return 0;
406 }
407 /*--------------------------------------------------------------------------*/
408 char sciGetyLocation(sciPointObj * pObj)
409 {
410         return 0;
411 }
412 /*--------------------------------------------------------------------------*/
413 sciLegendPlace sciGetLegendPlace (sciPointObj * pobj)
414 {
415         return (sciLegendPlace)0;
416 }
417 /*--------------------------------------------------------------------------*/
418 void sciGetDataBounds( sciPointObj * pObj, double bounds[6] )
419 {
420
421 }
422 /*--------------------------------------------------------------------------*/
423 void sciGetViewingArea(sciPointObj * pObj, int * xPos, int * yPos, int * width, int * height)
424 {
425
426 }
427 /*--------------------------------------------------------------------------*/
428 void destroyGraphicPointer(void * pointer)
429 {
430
431 }
432 /*--------------------------------------------------------------------------*/
433 int ComputeXIntervals( char * pobjUID, char xy_type, double ** vector, int * N, int checkdim )
434 {
435         return -1;
436 }
437 /*--------------------------------------------------------------------------*/
438 void deleteMatrix( sciMatrix * mat )
439 {
440
441 }
442 /*--------------------------------------------------------------------------*/
443 char * getStrMatElement( const StringMatrix * mat, int row, int col )
444 {
445         return NULL;
446 }
447 /*--------------------------------------------------------------------------*/
448 StringMatrix * computeDefaultTicsLabels( char * pobjUID )
449 {
450         return NULL;
451 }
452 /*--------------------------------------------------------------------------*/
453 void rotate2D( double from[2], double center[2], double angle, double dest[2] )
454 {
455
456 }
457 /*--------------------------------------------------------------------------*/
458 BOOL sciGetAutoRotation ( sciPointObj * pObj )
459 {
460         return FALSE;
461 }
462 /*--------------------------------------------------------------------------*/
463 BOOL needsDisplay(sciPointObj * pFigure)
464 {
465         return FALSE;
466 }
467 /*--------------------------------------------------------------------------*/
468 BOOL sciGetIsAutoDrawable( sciPointObj * pobj )
469 {
470         return FALSE;
471 }
472 /*--------------------------------------------------------------------------*/
473 void stringArrayCopy( char * dest[], char * src[], int nbElement )
474 {
475
476 }
477 /*--------------------------------------------------------------------------*/
478 BOOL sciGetVisibility (sciPointObj * pobj)
479 {
480         return FALSE;
481 }
482 /*--------------------------------------------------------------------------*/
483 void sciGetLogFlags(char *pObjUID, char flags[3])
484 {
485
486 }
487 /*--------------------------------------------------------------------------*/
488 int sciSetFontOrientation (char * pobj, double textorientation)
489 {
490         return -1;
491 }
492 /*--------------------------------------------------------------------------*/
493 BOOL sciGetAutoPosition ( sciPointObj * pObj )
494 {
495         return FALSE;
496 }
497 /*--------------------------------------------------------------------------*/
498 int sciSetFontStyle (char * pobj, int iAttributes )
499 {
500         return -1;
501 }
502 /*--------------------------------------------------------------------------*/
503 int sciInitIsClipping(char * pobj, int value)
504 {
505         return -1;
506 }
507 /*--------------------------------------------------------------------------*/
508 int sciSetLegendPos (char * pobj, double position[])
509 {
510         return -1;
511 }
512 /*--------------------------------------------------------------------------*/
513 int sciSetClipping (char * pobj, double pclip[4] )
514 {
515         return -1;
516 }
517 /*--------------------------------------------------------------------------*/
518 int sciSetTextPos( char * pObj, double posX, double posY, double posZ)
519 {
520         return -1;
521 }
522 /*--------------------------------------------------------------------------*/
523 void sciGetUserSize( sciPointObj * pObj, double * width, double * height )
524 {
525
526 }
527 /*--------------------------------------------------------------------------*/
528 BOOL sciGetIsBoxed (sciPointObj * pobj)
529 {
530         return FALSE;
531 }
532 /*--------------------------------------------------------------------------*/
533 BOOL sciGetIsLine (sciPointObj * pobj)
534 {
535         return FALSE;
536 }
537 /*--------------------------------------------------------------------------*/
538 BOOL sciGetAutoSize( sciPointObj * pObj )
539 {
540         return FALSE;
541 }
542 /*--------------------------------------------------------------------------*/
543 BOOL sciGetCenterPos( sciPointObj * pObj )
544 {
545         return FALSE;
546 }
547 /*--------------------------------------------------------------------------*/
548 BOOL sciisTextEmpty( char* identifier )
549 {
550         return FALSE;
551 }
552 /*--------------------------------------------------------------------------*/
553 double sciGetFontOrientation (sciPointObj * pobj)
554 {
555         return 0.;
556 }
557 /*--------------------------------------------------------------------------*/
558 sciTextAlignment sciGetAlignment( sciPointObj * pObj )
559 {
560         return (sciTextAlignment)0;
561 }
562 /*--------------------------------------------------------------------------*/
563 StringMatrix * sciGetText (sciPointObj * pobj)
564 {
565         return NULL;
566 }
567 /*--------------------------------------------------------------------------*/
568 int getMatNbCol( const sciMatrix * mat )
569 {
570         return -1;
571 }
572 /*--------------------------------------------------------------------------*/
573 int getMatNbRow( const sciMatrix * mat )
574 {
575         return -1;
576 }
577 /*--------------------------------------------------------------------------*/
578 char ** getStrMatData(  const StringMatrix * mat )
579 {
580         return NULL;
581 }
582 /*--------------------------------------------------------------------------*/
583 BOOL sciGetUseNurbs(sciPointObj * pObj)
584 {
585         return FALSE;
586 }
587 /*--------------------------------------------------------------------------*/
588 BOOL isFigureModel(sciPointObj * pObj)
589 {
590         return FALSE;
591 }
592 /*--------------------------------------------------------------------------*/
593 BOOL sciGetIsUsingFractionalMetrics(sciPointObj * pObj)
594 {
595         return FALSE;
596 }
597 /*--------------------------------------------------------------------------*/
598 sciFont *sciGetFontContext (sciPointObj * pobj)
599 {
600         return NULL;
601 }
602 /*--------------------------------------------------------------------------*/
603 double sciGetFontSize(sciPointObj * pobj)
604 {
605         return 0.;
606 }
607 /*--------------------------------------------------------------------------*/
608  int sciGetFontStyle (sciPointObj * pobj)
609 {
610         return -1;
611 }
612 /*--------------------------------------------------------------------------*/
613 void sciGetAxesVisible(sciPointObj * pObj, BOOL axesVisible[3])
614 {
615
616 }
617 /*--------------------------------------------------------------------------*/
618 void sciGetAutoTicks(sciPointObj * pObj, BOOL autoTicks[3])
619 {
620
621 }
622 /*--------------------------------------------------------------------------*/
623 void sciGetGridStyle( sciPointObj * pObj, int * xStyle, int * yStyle, int * zStyle )
624 {
625
626 }
627 /*--------------------------------------------------------------------------*/
628 BOOL sciGetAutoSubticks(sciPointObj * pObj)
629 {
630         return FALSE;
631 }
632 /*--------------------------------------------------------------------------*/
633 BOOL sciGetGridFront(sciPointObj * pObj)
634 {
635         return FALSE;
636 }
637 /*--------------------------------------------------------------------------*/
638 BOOL sciGetIs3d( sciPointObj * pObj )
639 {
640         return FALSE;
641 }
642 /*--------------------------------------------------------------------------*/
643 int sciGetSubwinIndex(sciPointObj * pSubwin)
644 {
645         return -1;
646 }
647 /*--------------------------------------------------------------------------*/
648 EAxesBoxType sciGetBoxType( sciPointObj * pobj )
649 {
650         return (EAxesBoxType)0;
651 }
652 /*--------------------------------------------------------------------------*/
653 void sciGetTextPos(sciPointObj * pObj, double position[3])
654 {
655
656 }
657 /*--------------------------------------------------------------------------*/
658 BOOL sciGetRealVisibility (sciPointObj * pobj)
659 {
660         return FALSE;
661 }
662 /*--------------------------------------------------------------------------*/
663 int getPixelModeIndex( const char * modeName )
664 {
665         return -1;
666 }
667 /*--------------------------------------------------------------------------*/
668 int sciSetXorMode (char * pobj, int value)
669 {
670         return -1;
671 }
672 /*--------------------------------------------------------------------------*/
673 int sciSetVisibility (char * pobj, BOOL value)
674 {
675         return -1;
676 }
677 /*--------------------------------------------------------------------------*/
678 void sciGetDisplayedDataBounds(sciPointObj * pObj, double bounds[6])
679 {
680
681 }
682 /*--------------------------------------------------------------------------*/
683 BOOL sciGetZooming (sciPointObj * pobj)
684 {
685         return FALSE;
686 }
687 /*--------------------------------------------------------------------------*/
688 BOOL sciGetTightLimitsOn(sciPointObj * pObj)
689 {
690         return FALSE;
691 }
692 /*--------------------------------------------------------------------------*/
693 int sciSetRealDataBounds(char * pObj, const double bounds[6])
694 {
695         return FALSE;
696 }
697 /*--------------------------------------------------------------------------*/
698 void mat4DMult(const double mat4D[4][4], const double vect3D[3], double res[3])
699 {
700
701 }
702 /*--------------------------------------------------------------------------*/
703 void setToIdentity(double mat4D[4][4])
704 {
705
706 }
707 /*--------------------------------------------------------------------------*/
708 BOOL sciGetIsIsoView(sciPointObj * pObj)
709 {
710         return FALSE;
711 }
712 /*--------------------------------------------------------------------------*/
713 void vectAdd3D(const double v1[3], const double v2[3], double res[3])
714 {
715
716 }
717 /*--------------------------------------------------------------------------*/
718 char *ConstructPolyline (char * pparentsubwin, double *pvecx, double *pvecy, double *pvecz,
719                          int closed, int n1, int plot, int *foreground, int *background,
720                          int *mark_style, int *mark_foreground, int *mark_background,
721                          BOOL isline, BOOL isfilled, BOOL ismark, BOOL isinterpshaded)
722 {
723         return NULL;
724 }
725 /*--------------------------------------------------------------------------*/
726 int sciSetIsClipping (char * pobj, int value)
727 {
728         return -1;
729 }
730 /*--------------------------------------------------------------------------*/
731 BOOL isPointInTriangle(const double point[2], const double a[2],
732                                            const double b[2], const double c[2])
733 {
734         return FALSE;
735 }
736 /*--------------------------------------------------------------------------*/
737 void vectSubstract2D(const double vect1[2], const double vect2[], double res[2])
738 {
739
740 }
741 /*--------------------------------------------------------------------------*/
742 void scalarMult2D(const double v[2], const double scalar, double res[2])
743 {
744
745 }
746 /*--------------------------------------------------------------------------*/
747 void vectAdd2D(const double v1[2], const double v2[2], double res[2])
748 {
749
750 }
751 /*--------------------------------------------------------------------------*/
752 int sciSetZoomBox(char * pObj, const double zoomBox[6])
753 {
754         return -1;
755 }
756 /*--------------------------------------------------------------------------*/
757 double *sciGetMargins( sciPointObj * pObj )
758 {
759         return NULL;
760 }
761 /*--------------------------------------------------------------------------*/
762 double * sciGetAxesBounds( sciPointObj * pObj )
763 {
764         return NULL;
765 }
766 /*--------------------------------------------------------------------------*/
767 void sciGetViewingAngles( sciPointObj * pObj, double * alpha, double * theta)
768 {
769
770 }
771 /*--------------------------------------------------------------------------*/
772 void sciGetAxesReverse(sciPointObj * pObj, BOOL axesReverse[3])
773 {
774
775 }
776 /*--------------------------------------------------------------------------*/
777 BOOL sciGetIsCubeScaled(sciPointObj * pObj)
778 {
779         return FALSE;
780 }
781 /*--------------------------------------------------------------------------*/
782 void vectSubstract3D(const double v1[3], const double v2[3], double res[3])
783 {
784
785 }
786 /*--------------------------------------------------------------------------*/
787 void normalize3D( double vect[3] )
788 {
789
790 }
791 /*--------------------------------------------------------------------------*/
792 void scalarMult3D(const double v[3], double scalar, double res[3])
793 {
794
795 }
796 /*--------------------------------------------------------------------------*/
797 int TheTicks( double * xminv ,
798                          double * xmaxv ,
799                          double * grads ,
800                          int    * ngrads,
801                          int      compNgrads )
802 {
803         return -1;
804 }
805 /*--------------------------------------------------------------------------*/
806 void ChoixFormatE(char *fmt, double xmin, double xmax, double xpas)
807 {
808
809 }
810 /*--------------------------------------------------------------------------*/
811 int GradLog( double _min, double _max, double *_grads, int * n_grads, int compNgrads)
812 {
813         return -1;
814 }
815 /*--------------------------------------------------------------------------*/
816 int ComputeNbSubTics(char * pobjUID, int nbtics, char logflag, const double * grads, int nbsubtics_input)
817 {
818         return -1;
819 }
820 /*--------------------------------------------------------------------------*/
821 int sciGetMarkStyle (sciPointObj * pobj)
822 {
823         return -1;
824 }
825 /*--------------------------------------------------------------------------*/
826 int sciGetMarkSize (sciPointObj * pobj)
827 {
828         return -1;
829 }
830 /*--------------------------------------------------------------------------*/
831 int sciGetMarkSizeUnit (sciPointObj * pobj)
832 {
833         return -1;
834 }
835 /*--------------------------------------------------------------------------*/
836 int sciGetLineStyle (sciPointObj * pobj)
837 {
838         return -1;
839 }
840 /*--------------------------------------------------------------------------*/
841 double sciGetLineWidth (sciPointObj * pobj)
842 {
843         return 0.;
844 }
845 /*--------------------------------------------------------------------------*/
846 double sciGetArrowSize (sciPointObj * pobj)
847 {
848         return 0.;
849 }
850 /*--------------------------------------------------------------------------*/
851 sciGraphicContext *sciGetGraphicContext (sciPointObj * pobj)
852 {
853         return NULL;
854 }
855 /*--------------------------------------------------------------------------*/
856 int * sciGetInterpVector(sciPointObj * pobj)
857 {
858         return NULL;
859 }
860 /*--------------------------------------------------------------------------*/
861 void intArrayCopy( int dest[], const int src[], int nbElement )
862 {
863
864 }
865 /*--------------------------------------------------------------------------*/
866 BOOL sciGetIsClosed(sciPointObj * pObj)
867 {
868         return FALSE;
869 }
870 /*--------------------------------------------------------------------------*/
871 BOOL sciGetIsFilled (sciPointObj * pobj)
872 {
873         return FALSE;
874 }
875 /*--------------------------------------------------------------------------*/
876 BOOL sciGetIsColorInterpolated(sciPointObj * pobj)
877 {
878         return FALSE;
879 }
880 /*--------------------------------------------------------------------------*/
881 BOOL sciGetIsDisplayingLines(sciPointObj * pObj)
882 {
883         return FALSE;
884 }
885 /*--------------------------------------------------------------------------*/
886 BOOL sciGetIsMark (sciPointObj * pobj)
887 {
888         return FALSE;
889 }
890 /*--------------------------------------------------------------------------*/
891 int sciGetNbPoints(sciPointObj * pObj)
892 {
893         return -1;
894 }
895 /*--------------------------------------------------------------------------*/
896 void doubleArrayCopy( double dest[], const double src[], int nbElement )
897 {
898
899 }
900 /*--------------------------------------------------------------------------*/
901 void setDoubleArraySingleValue( double dest[], double value, int nbElement )
902 {
903
904 }
905 /*--------------------------------------------------------------------------*/
906 int sciGetPolylineStyle(sciPointObj * pObj)
907 {
908         return -1;
909 }
910 /*--------------------------------------------------------------------------*/
911 void unzoomSubwin(sciPointObj * pSubwin)
912 {
913
914 }
915 /*--------------------------------------------------------------------------*/
916 void sciZoomObject(sciPointObj * pObj, int x1, int y1, int x2, int y2)
917 {
918
919 }
920 /*--------------------------------------------------------------------------*/
921 sciPointObj * getClickedSubwin(sciPointObj * pFigure, int xCoord, int yCoord)
922 {
923         return NULL;
924 }
925 /*--------------------------------------------------------------------------*/
926 void updateViewingAngles(sciPointObj * pSubwin, double deltaAlpha, double deltaTheta)
927 {
928
929 }
930 /*--------------------------------------------------------------------------*/
931 int deallocatePolyline (sciPointObj * pthis)
932 {
933         return -1;
934 }
935 /*--------------------------------------------------------------------------*/
936 int sciGetXorMode (sciPointObj * pobj)
937 {
938         return -1;
939 }
940 /*--------------------------------------------------------------------------*/
941 sciSons *sciGetLastSons (sciPointObj * pobj)
942 {
943         return NULL;
944 }
945 /*--------------------------------------------------------------------------*/
946 BOOL sciIsAutomaticallyRedrawn(sciPointObj * pObj)
947 {
948         return TRUE;
949 }
950 /*--------------------------------------------------------------------------*/
951 int sciGetIsClipping (sciPointObj * pobj)
952 {
953         return -1;
954 }
955 /*--------------------------------------------------------------------------*/
956 sciPointObj *sciGetParentSubwin (sciPointObj * pobj)
957 {
958         return NULL;
959 }
960 /*--------------------------------------------------------------------------*/
961 void sciGetRealDataBounds( sciPointObj * pObj, double bounds[6] )
962 {
963
964 }
965 /*--------------------------------------------------------------------------*/
966 int sciInitMarkSize(char * pobj, int marksize)
967 {
968         return -1;
969 }
970 /*--------------------------------------------------------------------------*/
971 double *sciGetClipping (sciPointObj * pobj)
972 {
973         return NULL;
974 }
975 /*--------------------------------------------------------------------------*/
976 BOOL sciIsExistingFigure(int figNum)
977 {
978         return FALSE;
979 }