SGraph.c File Reference

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include "sci_mem_alloc.h"
#include "GetProperty.h"
#include "DestroyObjects.h"
#include "SGraph.h"
#include "xs2file.h"
#include "Xcall1.h"
#include "WindowList.h"
#include "Actions.h"
#include "periWin.h"
#include "math.h"
#include "men_Sutils.h"
#include "men_scilab.h"
#include "All-extern.h"
#include "All-extern-x1.h"
#include "Events.h"

Include dependency graph for SGraph.c:

Go to the source code of this file.

Data Structures
struct	MenuData
Defines
#define	DEFAULT_MES   "graphic window"
#define	WINMINW   100
#define	WINMINH   100
#define	FDEBUG(x)
#define	FDEBUG_EP1(x)
Typedefs
typedef struct MenuData *	MenuDataPtr
Functions
int StoreCommand	__PARAMS ((char *command))
char *	getenv ()
int	getpid ()
Widget initColors	__PARAMS ((Widget))
Window GetBGWindowNumber	__PARAMS ((int))
void DisplayInit	__PARAMS ((char *string, Display **dpy, Widget *toplevel))
void ChangeBandF	__PARAMS ((int win_num, Pixel fg, Pixel bg))
integer	F2C (fbutn)
int	IswmDeleteWindow (XEvent *event)
int	IsCloseSGWindow (XEvent *event)
static void	reset_click_counter (XtPointer ptr)
void	btn_pressed (Widget widget, XEvent *event, String *params, Cardinal *num_params)
void	btn_released (Widget widget, XEvent *event, String *params, Cardinal *num_params)
void	ctrl_key (Widget widget, XEvent *event, String *params, Cardinal *num_params)
void	key_pressed (Widget widget, XEvent *event, String *params, Cardinal *num_params)
void	key_released (Widget widget, XEvent *event, String *params, Cardinal *num_params)
void	mouse_moved (Widget widget, XEvent *event, String *params, Cardinal *num_params)
static int	AddNewWin (int popupc, struct BCG *ScilabXgc)
void	PannerCallback (Widget w, XtPointer scigc_ptr, XtPointer report_ptr)
void	SciViewportMove (struct BCG *ScilabXgc, int x, int y)
void	SciViewportGet (struct BCG *ScilabXgc, int *x, int *y)
void	SciViewportClipGetSize (struct BCG *ScilabXgc, int *w, int *h)
void	sci_pixmap_resize (struct BCG *Xgc, int x, int y)
void	ViewportCallback (Widget w, XtPointer scigc_ptr, XtPointer report_ptr)
void	SetBar (Widget w, Position top, Dimension length, Dimension total)
void	RedrawThumbs (ViewportWidget w)
static void	MoveChild (Widget viewp, Position x, Position y)
void	GViewportResize (struct BCG *ScilabXgc, int *width, int *height)
void	GPopupResize (struct BCG *ScilabXgc, int *width, int *height)
static void	ignore_events (Widget widget, XEvent *event2, long mask)
static XtEventHandler	EventProc1 (Widget widget, XtPointer number, XEvent *event)
static void	Efface (Widget w, XtPointer number, XtPointer client_data)
static void	Select (Widget w, XtPointer number, XtPointer client_data)
int	get_xclick_client_message_flag (void)
static void	Delete (Widget w, XtPointer number, XtPointer client_data)
int C2F()	deletewin (integer *number)
static void	Print (Widget w, XtPointer number, XtPointer client_data)
void	scig_print (integer number)
static void	SavePs (Widget w, XtPointer number, XtPointer client_data)
void	scig_export (integer number)
static void	Save (Widget w, XtPointer number, XtPointer client_data)
static void	Load (Widget w, XtPointer number, XtPointer client_data)
static void	Zoom (Widget w, XtPointer number, XtPointer client_data)
static void	UnZoom (Widget w, XtPointer number, XtPointer client_data)
static void	Rot3D (Widget w, XtPointer number, XtPointer client_data)
void	SGDeleteWindow (Widget w, XEvent *event, String *params, Cardinal *num__PARAMS)
void	CreatePopupWindow (integer WinNum, Widget button, struct BCG *ScilabXgc, Pixel *fg, Pixel *bg)
void	ChangeBandF (int win_num, Pixel fg, Pixel bg)
static void	ChangeBF1 (Widget w, char *str, Pixel fg, Pixel bg)
static void	KillButton (Widget w, XtPointer client_data, caddr_t call_data)
static void	SelMenu (Widget w, XtPointer client_data, caddr_t call_data)
int C2F()	delbtn (integer *win_num, char *button_name)
void	AddMenu (integer *win_num, char *button_name, char **entries, integer *ne, integer *typ, char *fname, integer *ierr)
int C2F()	addmen (integer *win_num, char *button_name, integer *entries, integer *ptrentries, integer *ne, integer *typ, char *fname, integer *ierr)
static void	SetUnsetMenu (integer *win_num, char *button_name, integer *ne, int flag)
int C2F()	setmen (integer *win_num, char *button_name, integer *entries, integer *ptrentries, integer *ne, integer *ierr)
int C2F()	unsmen (integer *win_num, char *button_name, integer *entries, integer *ptrentries, integer *ne, integer *ierr)
static int	GetChilds (int win_num, int *nc, WidgetList *wL, Widget *outer, char *name, int *name_pos)
int	getNbSubMenus (int winNumber, char *menuName)
void	refreshMenus (struct BCG *ScilabGC)
Variables
XtAppContext	app_con
static Bool	wait_dclick = FALSE
static Bool	dclick = FALSE
static Bool	lose_up = FALSE
static long	timerId
static XtActionsRec	event_actions []
static String	event_translations
static char	bufname [256]
static char	printer [128]
static char	file [256]
static String	sg_trans
Widget	commandWindow

---

Define Documentation

#define DEFAULT_MES   "graphic window"

Definition at line 338 of file SGraph.c.

#define FDEBUG

(

x

)

Definition at line 815 of file SGraph.c.

Referenced by ignore_events().

#define FDEBUG_EP1

(

x

)

Definition at line 844 of file SGraph.c.

Referenced by EventProc1().

#define WINMINH   100

Definition at line 695 of file SGraph.c.

Referenced by GPopupResize(), and GViewportResize().

#define WINMINW   100

used when we resize the graphic window (i.e the drawbox) at Scilab level

Definition at line 694 of file SGraph.c.

Referenced by GPopupResize(), and GViewportResize().

---

Typedef Documentation

typedef struct MenuData* MenuDataPtr

---

Function Documentation

void ChangeBandF __PARAMS

(

(int win_num, Pixel fg, Pixel bg)

)

void DisplayInit __PARAMS

(

(char *string, Display **dpy, Widget *toplevel)

)

Window GetBGWindowNumber __PARAMS

(

(int)

)

Widget initColors __PARAMS

(

(Widget)

)

int StoreCommand __PARAMS

(

(char *command)

)

int C2F() addmen	(	integer *	win_num,
		char *	button_name,
		integer*	entries,
		integer*	ptrentries,
		integer*	ne,
		integer*	typ,
		char*	fname,
		integer*	ierr
	)

Definition at line 1634 of file SGraph.c.

References AddMenu(), FREE, i, ierr, NULL, and ScilabMStr2CM().

{
  char ** menu_entries = NULL ;
  int i ;
  *ierr =0;
  if (*ne!=0) {
    ScilabMStr2CM(entries,ne,ptrentries,&menu_entries,ierr);
    if ( *ierr == 1) return(0);
  }
  AddMenu(win_num,button_name,menu_entries,ne,typ,fname,ierr);
  /* ScilabMStr2CM allocate menu_entries */
  for ( i = 0 ; i  < *ne ; i++ )
  {
    FREE( menu_entries[i] ) ;
  }
  FREE( menu_entries ) ;
  return(0);
}

Here is the call graph for this function:

void AddMenu	(	integer *	win_num,
		char *	button_name,
		char **	entries,
		integer *	ne,
		integer *	typ,
		char *	fname,
		integer *	ierr
	)

Definition at line 1512 of file SGraph.c.

References args, command, commandWidgetClass, MenuData::entry, FALSE, MenuData::fname, GetChilds(), height, i, iargs, KillButton(), MALLOC, menuButtonWidgetClass, nc, NULL, SelMenu(), simpleMenuWidgetClass, smeBSBObjectClass, MenuData::type, w, width, MenuData::win_num, x, XtNfont, XtNfromHoriz, and XtNfromVert.

Referenced by addmen(), CreateGedMenus(), initgraphic(), and test_menu().

{  
  int newline,i;
  WidgetList childs;
  Widget outer,command,w,menu,entry;
  Position x;
  Dimension width,height,mainwidth,mainheight,bw=0;
  XFontStruct     *temp_font;
  char *func;
  MenuDataPtr datas;
  int nc, name_pos;
  if (GetChilds(*win_num,&nc,&childs,&outer,NULL,&name_pos)== FALSE) return;
  if ( nc < 2 ) return ; 
  iargs=0;
  XtSetArg(args[iargs], XtNx,&x);             iargs++;
  XtSetArg(args[iargs], XtNwidth,&width);     iargs++;
  XtSetArg(args[iargs], XtNheight,&height);     iargs++;
  XtSetArg(args[iargs], XtNfont, &temp_font);  iargs++;
  XtGetValues(childs[nc-1], args, iargs);
  iargs=0;
  XtSetArg(args[iargs], XtNwidth,&mainwidth);       iargs++;
  XtSetArg(args[iargs], XtNheight,&mainheight);       iargs++;
  XtGetValues(outer, args, iargs);

  bw= ( temp_font != NULL )? strlen(button_name)*((temp_font)->max_bounds.width) : 0;
  if ( (Dimension) (width+bw+x)  < mainwidth)
    {
      newline=0;
      iargs=0;
      XtSetArg(args[iargs], XtNfromVert,&w);  iargs++;
      XtGetValues(childs[nc-1], args, iargs);
      iargs=0;
      XtSetArg(args[iargs], XtNfromHoriz,childs[nc-1]);  iargs++;
      XtSetArg(args[iargs], XtNfromVert,w);  iargs++;
    }
  else
    {
      newline=1;
      iargs=0;
      XtSetArg(args[iargs], XtNfromVert,childs[nc-1]);  iargs++;
      XtSetArg(args[iargs], XtNfromHoriz,childs[0]);  iargs++;
    }

  func=(char *) MALLOC( (strlen(fname)+1)*(sizeof(char)));
  if ( func == ( char *) 0 ) 
    {
      *ierr=1 ;return;
    }
  strcpy(func,fname);

  XtSetArg(args[iargs], XtNheight,height);     iargs++;
  if (*ne==0) {
    command = XtCreateManagedWidget(button_name,
                                    commandWidgetClass,outer,args, iargs);
    datas= (MenuDataPtr) MALLOC(sizeof(MenuData) );
    if ( datas == (MenuDataPtr) 0) 
      {
        *ierr=1 ;return;
      }
    datas->win_num= *win_num;
    datas->entry=0;
    datas->type=*typ;
    datas->fname=func;
    XtAddCallback(command, XtNcallback,(XtCallbackProc) SelMenu,
                  (XtPointer)datas);
    XtAddCallback(command, XtNdestroyCallback,(XtCallbackProc) KillButton,
                  (XtPointer)datas);
  }
  else {
    command = XtCreateManagedWidget(button_name,
                                    menuButtonWidgetClass,outer,args, iargs);
    iargs=0;
    menu = XtCreatePopupShell("menu", simpleMenuWidgetClass, 
                              command,args, iargs);
    for (i=0;i<*ne;i++){
      iargs=0;
      entry= XtCreateManagedWidget(entries[i], smeBSBObjectClass, menu,
                                   args, iargs);
      datas= (MenuDataPtr) MALLOC(sizeof(MenuData) );
      if ( datas == (MenuDataPtr) 0) 
        {
          *ierr=1 ;return;
        }
      datas->win_num = *win_num;
      datas->entry=i;
      datas->type=*typ;
      datas->fname=func;
      XtAddCallback(entry,XtNcallback,(XtCallbackProc)SelMenu, 
                    (XtPointer)datas);
      XtAddCallback(entry, XtNdestroyCallback,(XtCallbackProc) KillButton,
                    (XtPointer)datas);
    }
  }
  if (newline==1) {
    /* here we should increase the height of scigmForm */
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int AddNewWin	(	int	popupc,
		struct BCG *	ScilabXgc
	)			[static]

Definition at line 340 of file SGraph.c.

References AddNewMenu(), args, boxWidgetClass, BCG::CinfoW, commandWidgetClass, Delete(), demo_menu_activate, BCG::drawbox, Efface(), EventProc1(), formWidgetClass, iargs, initColors(), labelWidgetClass, Load(), load, menuButtonWidgetClass, NULL, panedWidgetClass, BCG::Panner, PannerCallback(), pannerWidgetClass, BCG::popup, Print(), Rot3D(), Save(), SavePs(), ScilabXgc, Select(), simpleMenuWidgetClass, smeBSBObjectClass, UnZoom(), BCG::Viewport, ViewportCallback(), viewportWidgetClass, XtNlabel, XtNreportCallback, ZERO, and Zoom().

Referenced by CreatePopupWindow().

{
  Widget bbox,color;
  Widget outer,zoom_,rot3d,unzoom_,sel,menuform;
  Widget filebutton,filemenu,clear,prnt,save,load,delete,saveps;

  iargs=0;
  /* eventually add a box to check for visual type */
  color = initColors(ScilabXgc->popup); 
  outer = XtCreateManagedWidget( "scigForm", panedWidgetClass,
                                 color,
                                 args, iargs);

  iargs = 0;
  menuform = XtCreateManagedWidget( "scigmForm", formWidgetClass,outer,
                                  args, iargs);

  ScilabXgc->Panner = XtCreateManagedWidget("Panner", pannerWidgetClass, 
                                 menuform , NULL, ZERO);

  iargs=0;
  XtSetArg(args[iargs], XtNlabel," ");iargs++;
  ScilabXgc->CinfoW = XtCreateManagedWidget("scigraphicinfo",labelWidgetClass, 
                                     menuform, args, iargs);

  /* Menu File */
  iargs=0;
  filebutton = XtCreateManagedWidget("File",
                                  menuButtonWidgetClass,menuform,args, iargs);
  iargs=0;
  filemenu = XtCreatePopupShell("menu", simpleMenuWidgetClass, 
                            filebutton,args, iargs);
  iargs=0;
  clear = XtCreateManagedWidget("Clear", smeBSBObjectClass,filemenu,args, iargs);
  XtAddCallback(clear, XtNcallback,(XtCallbackProc) Efface,(XtPointer) popupc); 
  sel = XtCreateManagedWidget("Select", smeBSBObjectClass,filemenu,args, iargs);
  XtAddCallback(sel, XtNcallback,(XtCallbackProc) Select,(XtPointer) popupc); 
  prnt = XtCreateManagedWidget("Print", smeBSBObjectClass,filemenu,args, iargs);
  XtAddCallback(prnt, XtNcallback,(XtCallbackProc)  Print,(XtPointer) popupc);
  saveps = XtCreateManagedWidget("Export", smeBSBObjectClass,filemenu,args, iargs);
  XtAddCallback(saveps, XtNcallback,(XtCallbackProc)  SavePs,(XtPointer)popupc);
  save = XtCreateManagedWidget("Save", smeBSBObjectClass,filemenu,args, iargs);
  XtAddCallback(save, XtNcallback,(XtCallbackProc)  Save,(XtPointer)popupc);
  load = XtCreateManagedWidget("Load", smeBSBObjectClass,filemenu,args, iargs);
  XtAddCallback(load, XtNcallback,(XtCallbackProc)  Load,(XtPointer)popupc);
  delete = XtCreateManagedWidget("Close", smeBSBObjectClass,filemenu,args, iargs);
  XtAddCallback(delete, XtNcallback,(XtCallbackProc)  Delete,(XtPointer)popupc);
  
  /* Other buttons */
  zoom_ = XtCreateManagedWidget("Zoom", commandWidgetClass,menuform,args, iargs);
  XtAddCallback(zoom_, XtNcallback,(XtCallbackProc)  Zoom,
                (XtPointer) popupc);
  unzoom_ = XtCreateManagedWidget("UnZoom", commandWidgetClass,menuform,args, iargs);
  XtAddCallback(unzoom_, XtNcallback,(XtCallbackProc)  UnZoom,
                (XtPointer) popupc);
  rot3d = XtCreateManagedWidget("Rot3D", commandWidgetClass,menuform,args, iargs);
  XtAddCallback(rot3d, XtNcallback,(XtCallbackProc) Rot3D,
                (XtPointer) popupc);

  iargs =0;

  ScilabXgc->Viewport = XtCreateManagedWidget("graphicviewport",viewportWidgetClass,outer,args,iargs);

  bbox= XtCreateManagedWidget("bbox",boxWidgetClass,ScilabXgc->Viewport, args, iargs);

  /* I use a label in order to have foreground and background */
  iargs=0;
  XtSetArg(args[iargs], XtNlabel," ");iargs++;
  ScilabXgc->drawbox= XtCreateManagedWidget("scigraphic",labelWidgetClass,bbox, args, iargs);

  /* EventProc Must select the client Message Events */

  XtAddEventHandler(ScilabXgc->drawbox, ExposureMask| StructureNotifyMask,
                    False,
                    (XtEventHandler) EventProc1,
                    (XtPointer) popupc);  

  /* even if EventProc is unused by xclick or xgetmouse : the next line 
     set the proper mask for the drawbox window and this is necessary for 
     xclick and xgetmouse to work. Moreover this EventHandler keeps the 
     queue of unused events ok 
  */

  /* XtAddEventHandler(ScilabXgc->drawbox, 
                    ButtonPressMask|PointerMotionMask|ButtonReleaseMask|
                    KeyPressMask|KeyReleaseMask,False,
                    (XtEventHandler) EventProc, (XtPointer) popupc); */

  XtOverrideTranslations(ScilabXgc->drawbox,
                 XtParseTranslationTable(event_translations));
  XtAppAddActions(app_con, event_actions, XtNumber(event_actions));

  XtAddCallback( ScilabXgc->Viewport,
                XtNreportCallback, ViewportCallback, (XtPointer) ScilabXgc);
  XtAddCallback(ScilabXgc->Panner, 
                XtNreportCallback, PannerCallback, (XtPointer) ScilabXgc);

  /* For Graphic demo */
  if ( demo_menu_activate == 1 )  AddNewMenu(outer,ScilabXgc->drawbox);
  return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void btn_pressed	(	Widget	widget,
		XEvent *	event,
		String *	params,
		Cardinal *	num_params
	)

Definition at line 152 of file SGraph.c.

References FALSE, GetEventWindow(), NULL, PushClickQueue(), reset_click_counter(), and TRUE.

{
  
  /* The following instruction has been commented out not to lose btn_pressed 
     emited just before an xclick or xgemouse call
    if (!get_wait_click()) return;
  */

  if (wait_dclick) {
   /* If we are waiting for a double-click, we only handle Button events
      in a special fashion.*/
      wait_dclick = FALSE;
      dclick = TRUE;
      lose_up = FALSE;
      XtRemoveTimeOut (timerId);
      return;
 }
  timerId = XtAppAddTimeOut(app_con, MultiClickTime,
                             (XtTimerCallbackProc) reset_click_counter, (XtPointer) NULL);
  wait_dclick = TRUE;
  lose_up = FALSE;
  dclick = FALSE;

  /*Wait until wait_dclick becomes FALSE 
    - either because of two consecutive btn press
    - either because of timeout 
    - either because of a mouse move  */
  do {
    if (XtAppPending (app_con))
      XtAppProcessEvent (app_con, XtIMAll);
  }  while (wait_dclick); 

  /* So here, dclick&lose_up have correct values.*/

  if (dclick ) { /* double click detected [10 11 12]*/
     PushClickQueue(GetEventWindow(event),event->xbutton.x,
                     event->xbutton.y,
                     event->xbutton.button-1+10,0,0);
  }
  else  {
    if  (lose_up) { /* simple click detected [3 4 5]*/
      if (params[0][0]=='0')
        PushClickQueue(GetEventWindow(event),event->xbutton.x,
                       event->xbutton.y,
                       event->xbutton.button-1+3,0,0);
      else if (params[0][0]=='1') /*shift press*/
        PushClickQueue(GetEventWindow(event),event->xbutton.x,
                       event->xbutton.y,
                       event->xbutton.button-1+3+2000,0,0);
      else if (params[0][0]=='2') /*ctrl press*/
        PushClickQueue(GetEventWindow(event),event->xbutton.x,
                       event->xbutton.y,
                       event->xbutton.button-1+3+1000,0,0);

      lose_up = FALSE;
      
    }
    else { /* button pressed detected [0 1 2]*/
      if (params[0][0]=='0')
        PushClickQueue(GetEventWindow(event),event->xbutton.x,
                       event->xbutton.y,
                       event->xbutton.button-1,0,0);
      else if (params[0][0]=='1') /*shift press*/
        PushClickQueue(GetEventWindow(event),event->xbutton.x,
                       event->xbutton.y,
                       event->xbutton.button-1+2000,0,0);
      else if (params[0][0]=='2') /*ctrl press*/
        PushClickQueue(GetEventWindow(event),event->xbutton.x,
                       event->xbutton.y,
                       event->xbutton.button-1+1000,0,0);

    }
   
 }



}

Here is the call graph for this function:

void btn_released	(	Widget	widget,
		XEvent *	event,
		String *	params,
		Cardinal *	num_params
	)

Definition at line 232 of file SGraph.c.

References GetEventWindow(), PushClickQueue(), and TRUE.

{
  if (wait_dclick) {
    lose_up = TRUE;
    return;
  }
  if (dclick)  return;
 /* button released detected [-5 -4 -3]*/
  PushClickQueue(GetEventWindow(event),event->xbutton.x,
                 event->xbutton.y,
                 event->xbutton.button-6,0,1);
}

Here is the call graph for this function:

void ChangeBandF	(	int	win_num,
		Pixel	fg,
		Pixel	bg
	)

Definition at line 1313 of file SGraph.c.

References ChangeBF1(), DisplayInit(), dpy, getWindowXgcNumber(), NULL, BCG::popup, and toplevel.

Referenced by set_default_colormap3(), and setcolormap3().

{
  struct BCG *SciGc;
  Widget popup,toplevel;
  static Display *dpy = (Display *) NULL;
  DisplayInit("",&dpy,&toplevel);
  SciGc = getWindowXgcNumber(win_num);
  if ( SciGc != NULL ) 
    {
      popup = SciGc->popup;
      if (popup == NULL) return;
      ChangeBF1(popup,"*.scigForm.scigmForm.File",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.File.menu",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.File.menu.Clear",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.File.menu.Select",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.File.menu.Print",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.File.menu.Export",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.File.menu.Save",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.File.menu.Load",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.File.menu.Close",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.Zoom",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.UnZoom",fg,bg);
      ChangeBF1(popup,"*.scigForm.scigmForm.Rot3D",fg,bg);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ChangeBF1	(	Widget	w,
		char *	str,
		Pixel	fg,
		Pixel	bg
	)			[static]

Definition at line 1342 of file SGraph.c.

References args, iargs, NULL, sciprint(), and XtNforeground.

{
  Widget loc;
  loc = XtNameToWidget(w,str);
  if ( loc != NULL)  
    {
      iargs=0;
      XtSetArg(args[iargs], XtNforeground, fg); iargs++;
      XtSetArg(args[iargs], XtNbackground, bg); iargs++;
      XtSetValues(loc, args, iargs);
    }
  else
    {
      sciprint("widget %s not found\r\n",str);
    }
}

Here is the call graph for this function:

void CreatePopupWindow	(	integer	WinNum,
		Widget	button,
		struct BCG *	ScilabXgc,
		Pixel *	fg,
		Pixel *	bg
	)

Definition at line 1260 of file SGraph.c.

References AddNewWin(), args, BCG::CBGWindow, BCG::CWindow, DisplayInit(), dpy, BCG::drawbox, iargs, BCG::popup, ScilabXgc, toplevel, topLevelShellWidgetClass, x_bg_color, x_fg_color, and XtNforeground.

Referenced by initgraphic().

{
  Widget toplevel;
  Display *dpy;
  XColor x_fg_color,x_bg_color;
  static XSetWindowAttributes attributes;
  unsigned char winname[6];
  iargs=0;
  XtSetArg(args[iargs], XtNx, 100+20*WinNum % 200);     iargs++;
  XtSetArg(args[iargs], XtNy, 100+20*WinNum % 200);     iargs++;
  sprintf(popupname,"ScilabGraphic%d",(int)WinNum);
  XtSetArg(args[iargs],XtNtitle,popupname);iargs++;
  
  DisplayInit("",&dpy,&toplevel);
  MultiClickTime=XtGetMultiClickTime(dpy);

  /* 
  ScilabXgc->popup = XtCreatePopupShell(popupname,
                             topLevelShellWidgetClass, button, args, iargs); 
                             */
  ScilabXgc->popup = XtAppCreateShell("Xscilab",popupname,topLevelShellWidgetClass,dpy,
                                      args,iargs);
  AddNewWin((int) WinNum,ScilabXgc);
  XtPopup(ScilabXgc->popup, XtGrabNone);
  SetHints(ScilabXgc->popup);
  
  sprintf((char *)winname,"BG%d",(int)WinNum);
  XChangeProperty(XtDisplay(ScilabXgc->drawbox),
                  XtWindow(ScilabXgc->drawbox), XA_WM_NAME, XA_STRING, 8, 
                  PropModeReplace, winname, 5);
  attributes.backing_store = Always;
  attributes.bit_gravity = NorthWestGravity;
  XChangeWindowAttributes(XtDisplay((ScilabXgc->drawbox)), 
                          XtWindow((ScilabXgc->drawbox)),
                          CWBackingStore | CWBitGravity,&attributes);
  XSync(XtDisplay(ScilabXgc->popup),0);
  ScilabXgc->CWindow=XtWindow(ScilabXgc->drawbox);
  ScilabXgc->CBGWindow=XtWindow(ScilabXgc->popup);
  XtOverrideTranslations(ScilabXgc->popup, XtParseTranslationTable(sg_trans));
  /*  Getting the values of foreground and background */
  XtSetArg(args[0],XtNforeground, &x_fg_color.pixel);
  XtSetArg(args[1],XtNbackground, &x_bg_color.pixel);
  XtGetValues(ScilabXgc->drawbox,args,2);
  *fg = x_fg_color.pixel;
  *bg = x_bg_color.pixel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ctrl_key	(	Widget	widget,
		XEvent *	event,
		String *	params,
		Cardinal *	num_params
	)

Definition at line 246 of file SGraph.c.

References buf, compose_status, GetEventWindow(), NULL, and PushClickQueue().

{
  char buf[10];
  int ten=10;
  KeySym keysym;
  XComposeStatus compose_status = {NULL, 0};
  XLookupString((XKeyEvent *)&(event->xkey), buf, 
                ten, &keysym,&compose_status);
  /* <Ctrl> key  detected return  )keysym+1000 */
  PushClickQueue(GetEventWindow(event),event->xkey.x,
                 event->xkey.y,(int)keysym+1000,0,0);
}

Here is the call graph for this function:

int C2F() delbtn	(	integer *	win_num,
		char *	button_name
	)

Definition at line 1443 of file SGraph.c.

References args, FALSE, GetChilds(), h, i, iargs, int, nc, NULL, pos, v, w, XawChainTop, XtNbottom, XtNfromHoriz, XtNfromVert, and XtNtop.

{  
  int nc=0;
  WidgetList childs;
  Widget outer,h,v,w;
  int i,pos=0;
  int name_pos ;

  if (GetChilds(*win_num,&nc,&childs,&outer,button_name,&name_pos)== FALSE)
    return 0;
  if (name_pos  == -1 ) return 0; /* button_name not found */
  /* position in widget list */
  pos = name_pos +1;
  if ( pos==(int)nc ) 
    {
      /* button_name is the  last button : simply destroy it */
      XtDestroyWidget(childs[name_pos]);
      return 0;
    }
  iargs=0;
  XtSetArg(args[iargs], XtNfromHoriz,&h);    iargs++;
  XtSetArg(args[iargs], XtNfromVert,&v);     iargs++;
  XtGetValues(childs[pos-1], args, iargs);
  /* reconstruct next widget layout */
  iargs=0;
  XtSetArg(args[iargs], XtNfromHoriz,h);    iargs++;
  XtSetArg(args[iargs], XtNtop,XawChainTop); iargs++;
  XtSetArg(args[iargs], XtNbottom,XawChainTop); iargs++;
  XtSetValues(childs[pos], args, iargs);

  if (v!=NULL) {
    iargs=0;
    XtSetArg(args[iargs], XtNfromVert,v);    iargs++;
    XtSetArg(args[iargs], XtNtop,XawChainTop); iargs++;
    XtSetArg(args[iargs], XtNbottom,XawChainTop); iargs++;
    XtSetValues(childs[pos], args, iargs);
    for (i=pos+1;i<(int)nc;i++) {
      iargs=0;
      XtSetArg(args[iargs], XtNfromVert,&w);     iargs++;
      XtGetValues(childs[i], args, iargs);
      if (w== childs[pos-1]) {
        iargs=0;
        XtSetArg(args[iargs], XtNfromVert,v);     iargs++;
        XtSetArg(args[iargs], XtNtop,XawChainTop); iargs++;
        XtSetArg(args[iargs], XtNbottom,XawChainTop); iargs++;
        XtSetValues(childs[i], args, iargs);
      }
    }
  }
  /* destroy widget */
  if ( childs[pos-1] != NULL)
    XtDestroyWidget(childs[pos-1]);
  return(0);
}

Here is the call graph for this function:

static void Delete	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 978 of file SGraph.c.

References delete_sgwin_entities(), DeleteObjs(), DeleteSGWin(), Efface(), get_delete_win_mode(), get_xclick_client_message_flag(), PushClickQueue(), scig_deletegwin_handler, and wininfo().

Referenced by AddNewWin(), deletewin(), f_clos(), and SGDeleteWindow().

{
  int v_flag = 1;
  integer win_num = (integer) number ;
  if (  get_delete_win_mode() == 1 )
    {
      wininfo("Cannot destroy window while acquiring zoom rectangle ");
      return;
    }
  if ( get_xclick_client_message_flag() == 1 ) 
    {
      /* the client message is only used while waiting for 
       * a mouse click 
       */
      PushClickQueue(win_num,0,0,-100,0,0);
    }
  Efface((Widget) 0,(XtPointer) number, (XtPointer) 0);
  DeleteObjs(win_num);
  v_flag = 0;
  scig_deletegwin_handler(win_num);
  DeleteSGWin(win_num); /* Here we 1) destroy the ScilabXgc (set to NULL) if it is the last window in the list */
                        /*         2) or reset the ScilabXgc to the next one see DeleteSGWin*/

  /* So, we use another flag named v_flag :*/
  delete_sgwin_entities(win_num);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int C2F() deletewin

(

integer *

number

)

Definition at line 1008 of file SGraph.c.

References Delete(), and number.

                                    {
  Delete((Widget) 0,(XtPointer) *number,(XtPointer) 0);
  return(0);
}

Here is the call graph for this function:

static void Efface	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 921 of file SGraph.c.

References scig_erase().

Referenced by AddNewWin(), and Delete().

{
  integer win_num = (integer) number ;
  scig_erase(win_num);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static XtEventHandler EventProc1	(	Widget	widget,
		XtPointer	number,
		XEvent *	event
	)			[static]

Definition at line 849 of file SGraph.c.

References BCG::Cdrawable_flag, FDEBUG_EP1, getWindowXgcNumber(), ignore_events(), scig_expose(), and scig_resize().

Referenced by AddNewWin().

{
  XEvent event2;
  integer win_num= (integer) number;
  XExposeEvent *event1;
#ifdef EP1DEBUG
  static int counter=0;
  counter++;
#endif 
  switch (event->type) 
    {
    case Expose :
      event1= (XExposeEvent *) event;
      /* 
         FDEBUG_EP1((stderr,"EventProc1: Expose: count %d x %d y %d width %d height %d\n",
         event1->count ,event1->x,event1->y,event1->width,event1->height));
      */
      if ( event1->count == 0) 
        {
          struct BCG *SciGc =  getWindowXgcNumber(win_num );
          if ( SciGc->Cdrawable_flag ==  1) 
            {
              FDEBUG_EP1((stderr,"EventProc1: Expose: --> scig_resize %d \r\n",counter)); 
              SciGc->Cdrawable_flag = 0;
              scig_resize(win_num);
            }
          else 
            {
              FDEBUG_EP1((stderr,"EventProc1: Expose: --> scig_expose %d \r\n",counter)); 
              scig_expose(win_num);
            }
          ignore_events(widget,&event2, ExposureMask | StructureNotifyMask) ;
        }
      break;
    case VisibilityNotify :
      /* We should get there only if server does not performs save_under */
      FDEBUG_EP1((stderr,"EventProc1: VisibilityNotify\n"));
      break;
    case ConfigureNotify :
      FDEBUG_EP1((stderr,"EventProc1: ConfigureNotify %d \n",counter));
      scig_resize(win_num);
      ignore_events(widget,&event2, ExposureMask | StructureNotifyMask);
      break; 
    case CreateNotify  :
      FDEBUG_EP1((stderr,"EventProc1: CreateNotify\r\n",counter));
      break ;
    case MapNotify : 
      FDEBUG_EP1((stderr,"EventProc1: MapNotify\r\n",counter)); 
      ignore_events(widget,&event2, ExposureMask );
      break;
    case ReparentNotify :
      FDEBUG_EP1((stderr,"EventProc1: ReparentNotify\r\n"));
      break;
    default:
      FDEBUG_EP1((stderr,"EventProc1: default, event=%d window=%d\r\n",event->type,(int) win_num));
      return(0);
    }
  return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

integer F2C

(

fbutn

)

Definition at line 47 of file SGraph.c.

{
 XSizeHints             size_hints;
 size_hints.width       = 600;
 size_hints.height      = 400;
 size_hints.min_width   = 400;
 size_hints.min_height  = 300;
 size_hints.flags =  USSize | PMinSize;
 XSetNormalHints(XtDisplay(topW),XtWindow(topW), &size_hints);
 /*
  *  Add a protocol flag indicating we wish to handle
  *  WM_DELETE_WINDOW requests (in fact we ignore it)
  */
 wmDeleteWindow = XInternAtom(XtDisplay(topW), "WM_DELETE_WINDOW", False);
 XSetWMProtocols(XtDisplay(topW),XtWindow(topW),&wmDeleteWindow, 1);
 Close_SG_Window_Activated = XInternAtom(XtDisplay(topW), 
                                         "SCI_DELETE_WINDOW", False);
}

int get_xclick_client_message_flag

(

void

)

Definition at line 437 of file periX11.c.

Referenced by Delete().

{ return client_message;}

Here is the caller graph for this function:

static int GetChilds	(	int	win_num,
		int *	nc,
		WidgetList *	wL,
		Widget *	outer,
		char *	name,
		int *	name_pos
	)			[static]

Definition at line 1737 of file SGraph.c.

References args, DisplayInit(), dpy, FALSE, getWindowXgcNumber(), i, iargs, int, label, NULL, BCG::popup, toplevel, TRUE, and XtNlabel.

Referenced by AddMenu(), delbtn(), getNbSubMenus(), and SetUnsetMenu().

{ 
  Cardinal nc1=0;
  Widget popup,toplevel;
  char * label;
  static Display *dpy = (Display *) NULL;
  DisplayInit("",&dpy,&toplevel);
  if ( win_num == -1) 
    {
      *outer = commandWindow;
    }
  else 
    {
      struct BCG *SciGc;
      SciGc = getWindowXgcNumber(win_num);
      if ( SciGc ==  NULL ) return FALSE;
      if ((popup = SciGc->popup)== NULL) return FALSE;
      *outer=XtNameToWidget(popup,"*.scigForm.scigmForm");
      if (*outer == NULL) return FALSE;
    }
  iargs=0;
  XtSetArg(args[iargs], XtNnumChildren, &nc1);    iargs++;
  XtSetArg(args[iargs], XtNchildren, wL);   iargs++;
  XtGetValues(*outer, args, iargs);
  *nc=nc1;
  *name_pos = -1;
  if ( name != NULL) 
    {
      int i;
      for (i=0; i < (int)nc1;i++) 
        {
          iargs=0;
          label=NULL;
          XtSetArg(args[iargs], XtNlabel,&label);   iargs++;
          XtGetValues( (*wL)[i], args, iargs);
          if ( label != NULL && (strcmp(label,name)==0))
            {
              *name_pos = i;
              break;
            }
        }
    }
  return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* getenv

(

)

getpid

int getNbSubMenus	(	int	winNumber,
		char *	menuName
	)

Definition at line 1791 of file SGraph.c.

References args, FALSE, GetChilds(), iargs, NULL, and XtNmenuName.

{
  int        nbMenus        ;
  WidgetList subMenus       ;
  Widget     menu           ;
  Widget     subMenu        ;
  int        menuId         ;
  int        nbSubMenus = 0 ;
  String     mname      = NULL ;

  if ( GetChilds( winNumber ,
                  &nbMenus   ,
                  &subMenus ,
                  &menu     ,
                  menuName  ,
                  &menuId    )  == FALSE )
  { 
    return 0 ;
  }
  /* a submenu is specified by its position 
   * in the menu item list  (*ne) 
   */
  iargs=0;
  XtSetArg(args[iargs], XtNmenuName, &mname);
  iargs++;
  XtGetValues(subMenus[menuId], args, iargs);
  
  if ( mname == NULL )
  {
    return 0 ;
  }
  
  subMenu = XtNameToWidget(subMenus[menuId],mname) ;
  iargs = 0 ;
  XtSetArg(args[iargs], XtNnumChildren, &nbSubMenus);
  iargs++;
  XtGetValues( subMenu , args, iargs);
  
  return nbSubMenus ;
}

Here is the call graph for this function:

int getpid

(

)

void GPopupResize	(	struct BCG *	ScilabXgc,
		int *	width,
		int *	height
	)

used when we resize the popup at scilab level

Definition at line 791 of file SGraph.c.

References args, CPixmapResize1(), BCG::CWindow, FALSE, iargs, Max, NULL, BCG::popup, SB_HORZ, SB_VERT, sciGetScrollInfo(), sciGetwresize(), ScilabXgc, sciSetScrollInfo(), TRUE, WINMINH, WINMINW, x, and y.

{
  Dimension clwidth = Max(*width,  WINMINW);
  Dimension clheight= Max(*height, WINMINH);
  if ( ScilabXgc->popup!=(Widget)0) { /* check if it is not a tk canvas */
    iargs = 0;
    XtSetArg (args[iargs], XtNwidth, clwidth ); iargs++;
    XtSetArg (args[iargs], XtNheight,clheight); iargs++;
    XtSetValues (ScilabXgc->popup, args, iargs);
  }
}

Here is the call graph for this function:

void GViewportResize	(	struct BCG *	ScilabXgc,
		int *	width,
		int *	height
	)

Definition at line 697 of file SGraph.c.

References args, BCG::Cdrawable, BCG::CurResizeStatus, BCG::drawbox, Height, iargs, Max, BCG::Panner, BCG::popup, RedrawThumbs(), sci_pixmap_resize(), ScilabXgc, BCG::Viewport, w, Width, WINMINH, WINMINW, x, XtNcanvasHeight, XtNcanvasWidth, XtNsliderHeight, XtNsliderWidth, XtNsliderX, XtNsliderY, and y.

Referenced by xset_windowdim().

{
  int Width = Max(*width,  WINMINW);
  int Height= Max(*height, WINMINH);
  Position x,y;
  Dimension cwidth,cheight,clwidth,clheight,wv,hv;
  ViewportWidget w = (  ViewportWidget ) ScilabXgc->Viewport;
  register Widget clip = w->viewport.clip;
  register Widget child = w->viewport.child;

  if ( ScilabXgc->CurResizeStatus == 0) 
    {
      XtResizeWidget(ScilabXgc->drawbox ,Width,Height,0);
      if (ScilabXgc->Cdrawable != (Drawable) 0 ) /* ScilabXgc->CWindow ) */
        {
          sci_pixmap_resize(ScilabXgc,Width,Height);
        }
      /*
       * Resize the viewport child which contains the graphic widget 
       * we don't want the viewport child to be smaller than the 
       * clip region 
       */
      wv = Max(Width,clip->core.width);
      hv = Max(Height,clip->core.height);
      XtResizeWidget(child,wv,hv,0);
      RedrawThumbs(w);
      
      iargs = 0 ;
      XtSetArg (args[iargs], XtNx, &x); iargs++;
      XtSetArg (args[iargs], XtNy, &y); iargs++;
      XtSetArg (args[iargs], XtNwidth, &cwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight, &cheight); iargs++;
      XtGetValues (child, args, iargs);
      iargs = 0 ;
      XtSetArg (args[iargs], XtNwidth, &clwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight, &clheight); iargs++;
      XtGetValues (clip, args, iargs);
      iargs =0;
      XtSetArg (args[iargs], XtNsliderX, -x); iargs++;
      XtSetArg (args[iargs], XtNsliderY, -y); iargs++;
      XtSetArg (args[iargs], XtNsliderWidth, clwidth ); iargs++;
      XtSetArg (args[iargs], XtNsliderHeight, clheight); iargs++;
      XtSetArg (args[iargs], XtNcanvasWidth,  cwidth); iargs++;
      XtSetArg (args[iargs], XtNcanvasHeight,  cheight); iargs++;
      XtSetValues (ScilabXgc->Panner, args, iargs);
    }
  else
    {
      /* 
       * in order to resize the drawbox, we must resize the 
       * popup window.
       */
      iargs =0;
      XtSetArg (args[iargs], XtNwidth, &clwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight, &clheight); iargs++;
      XtGetValues (ScilabXgc->popup, args, iargs);
      iargs =0;
      XtSetArg (args[iargs], XtNwidth, &cwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight, &cheight); iargs++;
      XtGetValues (ScilabXgc->drawbox, args, iargs);
      /* we add to Width and Height the expected offset 
       * the drawbox can be bigger than the popup if 
       * we are comming back from a ScilabXgc->CurResizeStatus==0 state 
       */
      clwidth = Width  + Max(0,(int)clwidth - (int)cwidth);
      clheight= Height + Max(0,(int)clheight - (int)cheight);
      iargs = 0;
      XtSetArg (args[iargs], XtNwidth, clwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight,clheight); iargs++;
      XtSetValues (ScilabXgc->popup, args, iargs);
      if (ScilabXgc->Cdrawable != (Drawable) 0 ) /* ScilabXgc->CWindow ) */
        {
          iargs =0;
          XtSetArg (args[iargs], XtNwidth, &cwidth ); iargs++;
          XtSetArg (args[iargs], XtNheight, &cheight); iargs++;
          XtGetValues (ScilabXgc->drawbox, args, iargs);
          sci_pixmap_resize(ScilabXgc,cwidth,cheight); 
          /* scig_resize(ScilabXgc->CurWindow);  */
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ignore_events	(	Widget	widget,
		XEvent *	event2,
		long	mask
	)			[static]

Definition at line 819 of file SGraph.c.

References count, and FDEBUG.

Referenced by EventProc1().

{
  while (XCheckWindowEvent(XtDisplay(widget),XtWindow(widget),mask ,event2)==True)
    { 
      FDEBUG((stderr,"inside ignore_events count = %d\n",((XExposeEvent *) event2)->count));
    }
}

Here is the caller graph for this function:

int IsCloseSGWindow

(

XEvent *

event

)

if true the window number is returnde

Definition at line 126 of file SGraph.c.

{
  if ( event->type == ClientMessage &&
       ((XClientMessageEvent *)event)->message_type == Close_SG_Window_Activated )
    return event->xclient.data.l[0];
  else
    return -1;
}

int IswmDeleteWindow

(

XEvent *

event

)

to check that an event is of type wmDeleteWindow

Definition at line 117 of file SGraph.c.

References int.

{
  return event->type == ClientMessage &&
    event->xclient.data.l[0] == (int)wmDeleteWindow ;
}

void key_pressed	(	Widget	widget,
		XEvent *	event,
		String *	params,
		Cardinal *	num_params
	)

Definition at line 260 of file SGraph.c.

References buf, compose_status, GetEventWindow(), NULL, and PushClickQueue().

{
  char buf[10];
  int ten=10;
  KeySym keysym;
  XComposeStatus compose_status = {NULL, 0};
  XLookupString((XKeyEvent *)&(event->xkey), buf, 
                ten, &keysym,&compose_status);
  if ((int)keysym < XK_Shift_L ||(int)keysym ==XK_Delete ){
    /* regular key pressed detected. return  keysym */
    PushClickQueue(GetEventWindow(event),event->xkey.x,
                   event->xkey.y,(int)keysym,0,0);
  }
}

Here is the call graph for this function:

void key_released	(	Widget	widget,
		XEvent *	event,
		String *	params,
		Cardinal *	num_params
	)

Definition at line 275 of file SGraph.c.

References buf, compose_status, GetEventWindow(), NULL, and PushClickQueue().

{
  char buf[10];
  int ten=10;
  KeySym keysym;
  XComposeStatus compose_status = {NULL, 0};
  XLookupString((XKeyEvent *)&(event->xkey), buf, 
                ten, &keysym,&compose_status);
  if ((int)keysym <65000) {
    /* regular key released detected. return  -keysym */
    PushClickQueue(GetEventWindow(event),event->xkey.x,
                   event->xkey.y,-(int)keysym,0,1);
  }
}

Here is the call graph for this function:

static void KillButton	(	Widget	w,
		XtPointer	client_data,
		caddr_t	call_data
	)			[static]

Definition at line 1378 of file SGraph.c.

References MenuData::entry, MenuData::fname, and FREE.

Referenced by AddMenu().

{
  MenuDataPtr datas =(MenuDataPtr)client_data;
  if ( datas->entry == 0)
    FREE(datas->fname);
  FREE(datas);
}

Here is the caller graph for this function:

static void Load	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 1124 of file SGraph.c.

References C2F, cur, dr(), filename, GetFileWindow(), ierr, init, L, na, PD0, PI0, rep, and TRUE.

Referenced by AddNewWin().

{
  char *filename;
  integer win_num = (integer) number ;
  int ierr=0,rep;
  static char *init ="*.scg";
  rep=GetFileWindow(init,&filename,".",0,&ierr,"Load Graphic File");
  if ( ierr == 0 && rep == TRUE )
    {
      integer verb=0,cur,na;
      C2F(dr)("xget","window",&verb,&cur,&na,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);  
      C2F(dr)("xset","window",&win_num,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
          //      C2F(xloadplots)(filename,0L);
      C2F(dr)("xset","window",&cur,PI0,PI0,PI0,PI0,PI0,PD0,PD0,PD0,PD0,0L,0L);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mouse_moved	(	Widget	widget,
		XEvent *	event,
		String *	params,
		Cardinal *	num_params
	)

Definition at line 290 of file SGraph.c.

References FALSE, GetEventWindow(), and PushClickQueue().

{
  /*ignore_events(widget,&event2, ExposureMask) ;*/
  if (wait_dclick) { /*move during a double click detection*/
    wait_dclick=FALSE;
    XtRemoveTimeOut (timerId);
    return;
  }
  PushClickQueue(GetEventWindow(event),event->xbutton.x,
                 event->xbutton.y,
                 -1,1,0);
}

Here is the call graph for this function:

static void MoveChild	(	Widget	viewp,
		Position	x,
		Position	y
	)			[static]

Definition at line 671 of file SGraph.c.

References RedrawThumbs(), and w.

{
  ViewportWidget w =   (ViewportWidget) viewp;
  register Widget child = w->viewport.child;
  register Widget clip = w->viewport.clip;

  /* make sure we never move past right/bottom borders */
  if ((int) (x + clip->core.width) > (int) child->core.width)
    x = child->core.width - clip->core.width;

  if ((int) (y + clip->core.height) > (int ) child->core.height)
    y = child->core.height - clip->core.height;

  /* make sure we never move past left/top borders */
  if (x < 0) x = 0;
  if (y < 0) y = 0;

  XtMoveWidget(child, - x, - y);
  RedrawThumbs(w);
}

Here is the call graph for this function:

void PannerCallback	(	Widget	w,
		XtPointer	scigc_ptr,
		XtPointer	report_ptr
	)

Definition at line 459 of file SGraph.c.

References MoveChild(), report(), ScilabXgc, and BCG::Viewport.

Referenced by AddNewWin().

{
  struct BCG *ScilabXgc = ((struct BCG *) scigc_ptr);
  Widget viewport = ScilabXgc->Viewport;
  XawPannerReport *report = (XawPannerReport *) report_ptr;
  MoveChild(viewport, report->slider_x ,report->slider_y);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void Print	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 1023 of file SGraph.c.

References getenv(), ok, orientation, prtdlg(), scig_toPs(), and sciprint().

Referenced by AddNewWin(), and scig_print().

{
  char *p1;
  integer win_num = (integer) number ;
  integer colored,orientation,flag=1,ok;

  prtdlg(&flag,printer,&colored,&orientation,file,&ok);
  if (ok==1) 
    {
      if ( ( p1 = getenv("TMPDIR"))  == (char *) 0 )
        {
          sciprint("Cannot find environment variable TMPDIR\r\n");
        }

      sprintf(bufname,"%s/scilab-%d",p1,(int)win_num);
      scig_toPs(win_num,colored,bufname,"Pos");
      sprintf(bufname,"$SCI/bin/scilab -%s %s/scilab-%d %s",
              (orientation == 1) ? "print_l" : "print_p",
              p1,(int)win_num,printer);
      system(bufname);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RedrawThumbs

(

ViewportWidget

w

)

Definition at line 655 of file SGraph.c.

References SetBar(), and w.

{
  register Widget child = w->viewport.child;
  register Widget clip = w->viewport.clip;

  if (w->viewport.horiz_bar)
    SetBar( w->viewport.horiz_bar, -(child->core.x),
           clip->core.width, child->core.width );

  if (w->viewport.vert_bar)
    SetBar( w->viewport.vert_bar, -(child->core.y),
           clip->core.height, child->core.height );
}

Here is the call graph for this function:

void refreshMenus

(

struct BCG *

ScilabGC

)

Definition at line 1833 of file SGraph.c.

Referenced by initgraphic().

{}

Here is the caller graph for this function:

static void reset_click_counter

(

XtPointer

ptr

)

[static]

Definition at line 144 of file SGraph.c.

References FALSE.

Referenced by btn_pressed().

{
  dclick = FALSE;
  wait_dclick = FALSE;
}

Here is the caller graph for this function:

static void Rot3D	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 1198 of file SGraph.c.

References args, iargs, ne, scig_3drot(), and SetUnsetMenu().

Referenced by AddNewWin().

{
  integer win_num = (integer) number,ne=0;
  iargs=0;
  XtSetArg(args[iargs], XtNsensitive, False); iargs++;
  XtSetValues(w, args, iargs);
  SetUnsetMenu(&win_num,"UnZoom",&ne,False);
  SetUnsetMenu(&win_num,"Zoom",&ne,False);
  SetUnsetMenu(&win_num,"File",&ne,False);
  scig_3drot(win_num);
  iargs = 0;
  XtSetArg(args[iargs], XtNsensitive,True); iargs++;
  XtSetValues(w, args, iargs);
  SetUnsetMenu(&win_num,"UnZoom",&ne,True);
  SetUnsetMenu(&win_num,"Zoom",&ne,True);
  SetUnsetMenu(&win_num,"File",&ne,True);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void Save	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 1106 of file SGraph.c.

References filename, GetFileWindow(), ierr, init, rep, and TRUE.

Referenced by AddNewWin().

{
  char *filename;
  //  integer win_num = (integer) number ;
  int ierr=0,rep;
  static char *init ="*.scg";
  rep=GetFileWindow(init,&filename,".",0,&ierr,"Save Graphic File");
  if ( ierr == 0 && rep == TRUE )
    {
                //      C2F(xsaveplots)(&win_num,filename,0L);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void SavePs	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 1058 of file SGraph.c.

References ok, orientation, prtdlg(), and scig_toPs().

{
  integer win_num = (integer) number ;
  integer colored,orientation,flag=2,ok;
  prtdlg(&flag,printer,&colored,&orientation,file,&ok);
  if (ok==1) 
    {
      if (strncmp(printer,"Postscript",10)==0 ) 
        {
          scig_toPs(win_num,colored,file,"Pos");
        }
      else if (strcmp(printer,"Xfig")==0)
        {
          scig_toPs(win_num,colored,file,"Fig");
        }
      else if (strcmp(printer,"Gif")==0)
        {
          scig_toPs(win_num,colored,file,"GIF");
        }
      else if (strcmp(printer,"PPM")==0)
        {
          scig_toPs(win_num,colored,file,"PPM");
        }
      if ( strcmp(printer,"Postscript No Preamble") != 0)
        {
          sprintf(bufname,"$SCI/bin/scilab -%s %s %s",
                  ( orientation == 1) ? "save_l" : "save_p",file,printer);
          system(bufname);
        }
  }
}

Here is the call graph for this function:

void sci_pixmap_resize	(	struct BCG *	Xgc,
		int	x,
		int	y
	)

Resize the pixmap associated to CurWindow and store it back in the window List

Definition at line 498 of file periWin.c.

References BCG::Cdrawable, BCG::CWindow, hdc1, Max, NULL, PixmapClear(), sci_pixmapclear(), sciprint(), and TryToGetDC().

{
  HDC hdc1;
  HBITMAP hbmTemp;
  hdc1=TryToGetDC(ScilabGC->CWindow);
  hbmTemp = CreateCompatibleBitmap (hdc1,x,y);
  ReleaseDC(ScilabGC->CWindow,hdc1);
  if (!hbmTemp)
    {
      sciprint("Can't resize pixmap\r\n");
      return;
    }
  else
    {
      HBITMAP  hbmSave;
      hbmSave = SelectObject ( ScilabGC->hdcCompat, hbmTemp);
      if ( ScilabGC->hbmCompat != NULL)
        DeleteObject (ScilabGC->hbmCompat);
      ScilabGC->hbmCompat = hbmTemp;
      sci_pixmapclear(ScilabGC->hdcCompat, ScilabGC);
      /* XXX C2F(show)(PI0,PI0,PI0,PI0); */ 
    }
}

Here is the call graph for this function:

void scig_export

(

integer

number

)

Definition at line 1096 of file SGraph.c.

References NULL, SavePs(), and scig_command_scilabgc().

{
  SavePs(NULL,(XtPointer) number,NULL);
}

Here is the call graph for this function:

void scig_print

(

integer

number

)

Definition at line 1048 of file SGraph.c.

References NULL, Print(), PrintPs(), and scig_command_scilabgc().

{
  Print(NULL,(XtPointer) number,NULL);
}

Here is the call graph for this function:

void SciViewportClipGetSize	(	struct BCG *	ScilabXgc,
		int *	w,
		int *	h
	)

Definition at line 513 of file SGraph.c.

References _ViewportPart::clip, NULL, ScilabXgc, BCG::Viewport, and _ViewportRec::viewport.

Referenced by xset_wresize().

{
  if ( ScilabXgc != NULL) 
    {
      ViewportWidget widg = (  ViewportWidget ) ScilabXgc->Viewport;
      register Widget clip = widg->viewport.clip;
      *w = clip->core.width;
      *h = clip->core.height;
    }
}

Here is the caller graph for this function:

void SciViewportGet	(	struct BCG *	ScilabXgc,
		int *	x,
		int *	y
	)

SciViewportGet : used to get panner position through scilab command.

: struct BCG *ScilabGC : structure associated to a Scilab Graphic window int x,y : the x,y point of the graphic window to be moved at the up-left position of the viewport

: NONE

Author:

: Matthieu PHILIPPE

Date:

: Dec 1999

Definition at line 488 of file SGraph.c.

References args, dx, dy, n, NULL, BCG::Panner, ScilabXgc, XtNsliderX, and XtNsliderY.

{
  Widget panner;
  Cardinal n=0;
  if ( ScilabXgc != NULL) 
    {
      Dimension dx,dy;
      panner = ScilabXgc->Panner;
      XtSetArg (args[n], XtNsliderX, &dx); n++;  
      XtSetArg (args[n], XtNsliderY, &dy); n++;
      XtGetValues (panner, args, n);
      *x = dx; *y=dy;
    }
  else
    {
      *x=0;*y=0;
    }
}

void SciViewportMove	(	struct BCG *	ScilabXgc,
		int	x,
		int	y
	)

SciViewportMove : used to move the panner and the viewport interactively through scilab command.

: struct BCG *ScilabGC : structure associated to a Scilab Graphic window int x,y : the x,y point of the graphic window to be moved at the up-left position of the viewport

: NONE

Author:

: Matthieu PHILIPPE

Date:

: Dec 1999

Definition at line 470 of file SGraph.c.

References args, FALSE, max, min, MoveChild(), n, NULL, BCG::Panner, SB_HORZ, SB_VERT, sciGetScrollInfo(), ScilabXgc, sciSetScrollInfo(), TRUE, BCG::Viewport, XtNsliderX, and XtNsliderY.

{
  Widget viewport,panner;
  Cardinal n=0;
  if ( ScilabXgc != NULL) 
    {
      viewport = ScilabXgc->Viewport;
      panner = ScilabXgc->Panner;
      MoveChild(viewport,x,y);
      XtSetArg (args[n], XtNsliderX, x); n++;  
      XtSetArg (args[n], XtNsliderY, y); n++;
      XtSetValues (panner, args, n);
    }
}

Here is the call graph for this function:

static void Select	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 937 of file SGraph.c.

References scig_sel().

Referenced by AddNewWin(), and main().

{
  integer win_num = (integer) number ;
  scig_sel(win_num);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void SelMenu	(	Widget	w,
		XtPointer	client_data,
		caddr_t	call_data
	)			[static]

Definition at line 1394 of file SGraph.c.

References buf, C2F, MenuData::entry, F2C(), fbutn(), MenuData::fname, rep, setfbutn(), StoreCommand(), MenuData::type, and MenuData::win_num.

Referenced by AddMenu().

{
  static char buf[256];
  MenuDataPtr datas = (MenuDataPtr) client_data;
  if (datas->type == 0) 
    { 
      /* Interpreted mode : we store the action on a queue */
      if ( datas->win_num < 0 ) 
        {
          sprintf(buf,"execstr(%s(%d))",datas->fname,datas->entry+1);
        }
      else 
        {
          sprintf(buf,"execstr(%s_%d(%d))",datas->fname,datas->win_num,datas->entry+1);
        }
      StoreCommand(buf);
    }
  else if (datas->type == 2) 
    { 
      /* Interpreted mode : we store the action on a queue */
      if ( datas->win_num < 0 ) 
        {
          sprintf(buf,"%s(%d)",datas->fname,datas->entry+1);
        }
      else 
        {
          sprintf(buf,"%s(%d,%d)",datas->fname,datas->entry+1,datas->win_num);
        }
      StoreCommand(buf);
    }
  else
    { 
      /* hard coded mode */
      int rep ;
      C2F(setfbutn)(datas->fname,&rep);
      if ( rep == 0) 
        F2C(fbutn)((datas->fname),&(datas->win_num),&(datas->entry));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SetBar	(	Widget	w,
		Position	top,
		Dimension	length,
		Dimension	total
	)

Definition at line 647 of file SGraph.c.

References XawScrollbarSetThumb().

{
  XawScrollbarSetThumb(w, (float) top / (float) total, 
                       (float) length / (float) total );
}

Here is the call graph for this function:

int C2F() setmen	(	integer *	win_num,
		char *	button_name,
		integer*	entries,
		integer*	ptrentries,
		integer*	ne,
		integer*	ierr
	)

activate a menu (scilab interface)

Definition at line 1710 of file SGraph.c.

References getWindowXgcNumber(), tagMW::hMenu, tagTW::hWndParent, tagTW::lpmw, SciSetMenu(), SetUnsetMenu(), and textwin.

{
  SetUnsetMenu(win_num,button_name,ne,True);
  return(0);
}

Here is the call graph for this function:

static void SetUnsetMenu	(	integer *	win_num,
		char *	button_name,
		integer *	ne,
		int	flag
	)			[static]

Definition at line 1659 of file SGraph.c.

References args, FALSE, GetChilds(), iargs, nc, NULL, and XtNmenuName.

Referenced by Rot3D(), setmen(), unsmen(), and Zoom().

{  
  Cardinal nc=0;
  WidgetList childs;
  Widget outer;
  int nc1,name_pos;
  if (GetChilds(*win_num,&nc1,&childs,&outer,button_name,&name_pos)== FALSE) return;
  if (name_pos  == -1 ) return; /* button_name not found */
  if (*ne==0) 
    {
      iargs=0;
      XtSetArg(args[iargs],XtNsensitive,flag); iargs++;
      XtSetValues(childs[name_pos], args, iargs );
    }
  else 
    {
      Widget w1;
      String mname=NULL;
      /* a submenu is specified by its position 
       * in the menu item list  (*ne) 
       */
      iargs=0;
      XtSetArg(args[iargs], XtNmenuName, &mname);    iargs++;
      XtGetValues(childs[name_pos], args, iargs); 
      w1= (mname == NULL) ? NULL : XtNameToWidget(childs[name_pos],mname);
      if (w1==NULL) {
        iargs=0;
        XtSetArg(args[iargs],XtNsensitive,flag); iargs++;
        XtSetValues(childs[name_pos], args, iargs );
        return;
      }
      iargs=0;
      XtSetArg(args[iargs], XtNnumChildren, &nc);    iargs++;
      XtSetArg(args[iargs], XtNchildren, &childs);   iargs++;
      XtGetValues(w1, args, iargs); 
      if (*ne <= (int)nc) {
        iargs=0;
        XtSetArg(args[iargs],XtNsensitive,flag); iargs++;
        XtSetValues(childs[*ne-1], args, iargs ); 
      }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SGDeleteWindow	(	Widget	w,
		XEvent *	event,
		String *	params,
		Cardinal *	num__PARAMS
	)

returns the number of the deleted window or -1 if no deleted windows

sciprint("Le window manager veut tuer une fenetre graphique %d\n",i);

Definition at line 1233 of file SGraph.c.

References Delete(), GetBGWindowNumber(), getWinsMaxId(), and i.

{
  int i;
  Window Win = XtWindow(w), Win1;
  int wincount =  getWinsMaxId()+1;
  for (i=0 ; i < wincount ; i++) 
    {
      Win1=GetBGWindowNumber(i);
      if (Win1 == Win ) 
        {
          Delete((Widget) 0,(XtPointer) i,(XtPointer) 0);
          return ;
        }
    }
  return ;
}

Here is the call graph for this function:

int C2F() unsmen	(	integer *	win_num,
		char *	button_name,
		integer*	entries,
		integer*	ptrentries,
		integer*	ne,
		integer*	ierr
	)

Definition at line 1718 of file SGraph.c.

References getWindowXgcNumber(), tagMW::hMenu, tagTW::hWndParent, tagTW::lpmw, SciSetMenu(), SetUnsetMenu(), and textwin.

{
  SetUnsetMenu(win_num,button_name,ne,False);
  return(0);
}

Here is the call graph for this function:

static void UnZoom	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 1176 of file SGraph.c.

References args, iargs, and scig_unzoom().

Referenced by AddNewWin().

{
  integer win_num = (integer) number;
  iargs = 0;
  XtSetArg(args[iargs], XtNsensitive, False); iargs++;
  XtSetValues(w, args, iargs);
  scig_unzoom(win_num);
  iargs = 0;
  XtSetArg(args[iargs], XtNsensitive,True); iargs++;
  XtSetValues(w, args, iargs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ViewportCallback	(	Widget	w,
		XtPointer	scigc_ptr,
		XtPointer	report_ptr
	)

Definition at line 538 of file SGraph.c.

References args, BCG::Cdrawable, BCG::Cdrawable_flag, _ViewportPart::child, _ViewportPart::clip, BCG::CurResizeStatus, BCG::CWindowHeight, BCG::CWindowWidth, BCG::drawbox, iargs, Max, n, NULL, BCG::Panner, report(), ScilabXgc, _ViewportRec::viewport, XawPRSliderX, XawPRSliderY, XtNcanvasHeight, XtNcanvasWidth, XtNsliderHeight, XtNsliderWidth, XtNsliderX, and XtNsliderY.

Referenced by AddNewWin().

{
  Dimension cwidth,cheight,clwidth,clheight,gwidth,gheight;
  ViewportWidget viewpw = (  ViewportWidget ) w;
  register Widget clip = viewpw->viewport.clip;
  register Widget child = viewpw->viewport.child;

  Cardinal n = 0;
  XawPannerReport *report = (XawPannerReport *) report_ptr;
  struct BCG *ScilabXgc = ((struct BCG *) scigc_ptr);
  Widget panner = ScilabXgc->Panner;
  

  if ( ScilabXgc->CurResizeStatus  == 0) 
    {

      XtSetArg (args[n], XtNsliderX, report->slider_x); n++;
      XtSetArg (args[n], XtNsliderY, report->slider_y); n++;
      if (report->changed != (XawPRSliderX | XawPRSliderY)) {
        XtSetArg (args[n], XtNsliderWidth, report->slider_width); n++;
        XtSetArg (args[n], XtNsliderHeight, report->slider_height); n++;
        XtSetArg (args[n], XtNcanvasWidth, report->canvas_width); n++;
        XtSetArg (args[n], XtNcanvasHeight, report->canvas_height); n++;
        /*
          fprintf(stderr,"new reported %d %d %d %d \n",report->slider_width, report->slider_height,
          report->canvas_width, report->canvas_height);
        */
      }
      XtSetValues (panner, args, n);

      iargs = 0 ;
      XtSetArg (args[iargs], XtNwidth, &cwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight, &cheight); iargs++;
      XtGetValues (child, args, iargs);
      iargs = 0;
      XtSetArg (args[iargs], XtNwidth, &clwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight, &clheight); iargs++;
      XtGetValues (clip, args, iargs);

      if (  ScilabXgc->drawbox != NULL) 
        {
          int nw,nh;
          iargs = 0;
          XtSetArg (args[iargs], XtNwidth, &gwidth ); iargs++;
          XtSetArg (args[iargs], XtNheight, &gheight); iargs++;
          XtGetValues (ScilabXgc->drawbox, args, iargs);
          nw= Max(gwidth,clwidth);
          nh= Max(gheight,clheight);
          if ( nw < cwidth || nh < cheight )
            {
              XtResizeWidget(child,nw,nh,0);
              n=0;
              XtSetArg (args[n], XtNcanvasWidth, nw); n++;
              XtSetArg (args[n], XtNcanvasHeight,nh); n++;
              XtSetValues (panner, args, n);
            }
        }
    }
  else
    {
      iargs = 0 ;
      XtSetArg (args[iargs], XtNwidth, &cwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight, &cheight); iargs++;
      XtGetValues (child, args, iargs);
      iargs = 0;
      XtSetArg (args[iargs], XtNwidth, &clwidth ); iargs++;
      XtSetArg (args[iargs], XtNheight, &clheight); iargs++;
      XtGetValues (clip, args, iargs);
      if (   ScilabXgc->drawbox != NULL) 
        {
          /* We resize Scilab drawbox and update window dimensions */
          XtResizeWidget(ScilabXgc->drawbox,clwidth,clheight,0);
          ScilabXgc->CWindowWidth  = clwidth;
          ScilabXgc->CWindowHeight = clheight;
          XtResizeWidget(child,clwidth,clheight,0);
          /* if necessary we must resize the pixmap */
          if (ScilabXgc->Cdrawable != (Drawable) NULL) /* ScilabXgc->CWindow ) */
            {
              /* here the best stuff to do is a scig_resize 
               * scig_resize(ScilabXgc->CurWindow); 
               * unfortunately this callback is called too 
               * frequently when resizing and scig_resize can be slow 
               * thus we just resize the window pixmap 
               * and set a flag.
               * Thus the last expose will have to properly redraw the window
               */
              /* will be done by expose 
                 sci_pixmap_resize(ScilabXgc,ScilabXgc->CWindowWidth, 
                 ScilabXgc->CWindowHeight);
              */
              ScilabXgc->Cdrawable_flag=1;
            }
          n=0;
          XtSetArg (args[n], XtNsliderWidth, clwidth); n++;
          XtSetArg (args[n], XtNsliderHeight,clheight); n++;
          XtSetArg (args[n], XtNcanvasWidth, clwidth); n++;
          XtSetArg (args[n], XtNcanvasHeight,clheight); n++;
          XtSetValues (panner, args, n);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void Zoom	(	Widget	w,
		XtPointer	number,
		XtPointer	client_data
	)			[static]

Definition at line 1150 of file SGraph.c.

References args, iargs, ne, scig_2dzoom(), and SetUnsetMenu().

Referenced by AddNewWin().

{

  integer win_num = (integer) number,ne=0;
  iargs = 0;
  XtSetArg(args[iargs], XtNsensitive, False); iargs++;
  XtSetValues(w, args, iargs);
  SetUnsetMenu(&win_num,"3D Rot.",&ne,False);
  SetUnsetMenu(&win_num,"UnZoom",&ne,False);
  SetUnsetMenu(&win_num,"File",&ne,False);
  if(scig_2dzoom(win_num) != 1){ /* ==1 <=> zoom failed (the window has been closed while zooming ) */
    iargs = 0;
    XtSetArg(args[iargs], XtNsensitive,True); iargs++;
    XtSetValues(w, args, iargs);
  }
  SetUnsetMenu(&win_num,"3D Rot.",&ne,True);
  SetUnsetMenu(&win_num,"UnZoom",&ne,True);
  SetUnsetMenu(&win_num,"File",&ne,True);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

XtAppContext app_con

Definition at line 76 of file inter.c.

char bufname[256] [static]

Definition at line 1018 of file SGraph.c.

Widget commandWindow

Definition at line 72 of file command.c.

Bool dclick = FALSE [static]

Definition at line 140 of file SGraph.c.

XtActionsRec event_actions[] [static]

Initial value:

{
    {"BtnPressed", (XtActionProc) btn_pressed},
    {"BtnReleased", (XtActionProc) btn_released},
    {"CtrlKey", (XtActionProc) ctrl_key},
    {"KeyPressed", (XtActionProc) key_pressed},
    {"KeyReleased", (XtActionProc) key_released},
    {"MouseMoved", (XtActionProc) mouse_moved},
}

Definition at line 308 of file SGraph.c.

String event_translations [static]

Initial value:

"\
<MouseMoved>:MouseMoved()\n\
Ctrl<Key>:CtrlKey()\n\
!Shift<KeyDown>:KeyPressed(1)\n\
!Lock<KeyDown>:KeyPressed(1)\n\
!Lock Shift <KeyDown>:KeyPressed(0)\n\
None<KeyDown>:KeyPressed(0)\n\
!Shift<KeyUp>:KeyReleased(1)\n\
!Lock<KeyUp>:KeyReleased(1)\n\
!Lock Shift<KeyUp>:KeyReleased(1)\n\
None<KeyUp>:KeyReleased(0)\n\
<BtnUp>:BtnReleased()\n\
!Shift<BtnDown>:BtnPressed(1)\n\
!Ctrl<BtnDown>:BtnPressed(2)\n\
<BtnDown>:BtnPressed(0)\n\
"

Definition at line 318 of file SGraph.c.

char file[256] [static]

Definition at line 1020 of file SGraph.c.

Bool lose_up = FALSE [static]

Definition at line 141 of file SGraph.c.

char printer[128] [static]

Definition at line 1019 of file SGraph.c.

Referenced by CopyPrint(), and gp_printfile().

String sg_trans [static]

Initial value:

"<Message>WM_PROTOCOLS: SGDeleteWindow()\n\
     <ClientMessage>WM_PROTOCOLS: SGDeleteWindow()\n"

Definition at line 1256 of file SGraph.c.

long timerId [static]

Definition at line 142 of file SGraph.c.

Bool wait_dclick = FALSE [static]

Definition at line 139 of file SGraph.c.

---