static int itemConfigure( Tcl_Interp *interp, int objc, Tcl_Obj * const objv[], CanvasParams *param, GPtrArray *items ) { /* canvas itemConfigure tag-or-id ?option val ...? */ guint k; int ret = TCL_ERROR; if( items == NULL ) return TCL_OK; for( k = 0; k < items->len; ++k ) { Gnocl_CanvasItemInfo *info = GET_INFO( items, k ); if( gnoclParseOptions( interp, objc - 2, objv + 2, info->options ) != TCL_OK ) goto cleanExit; } for( k = 0; k < items->len; ++k ) { Gnocl_CanvasItemInfo *info = GET_INFO( items, k ); if( (*info->setOptions)( interp, info ) != TCL_OK ) goto cleanExit; } ret = TCL_OK; cleanExit: for( k = 0; k < items->len; ++k ) { Gnocl_CanvasItemInfo *info = GET_INFO( items, k ); gnoclClearOptions( info->options ); } return ret; }
/***f* socket/gnoclSocketCmd * AUTHOR * PGB * SOURCE */ int gnoclSocketCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret; GtkSocket *socket; if ( gnoclParseOptions ( interp, objc, objv, socketOptions ) != TCL_OK ) { gnoclClearOptions ( socketOptions ); return TCL_ERROR; } socket = GTK_SOCKET ( gtk_socket_new() ); gtk_widget_show ( GTK_WIDGET ( socket ) ); ret = gnoclSetOptions ( interp, socketOptions, G_OBJECT ( socket ), -1 ); if ( ret == TCL_OK ) ret = configure ( interp, socket, socketOptions ); gnoclClearOptions ( socketOptions ); if ( ret != TCL_OK ) { gtk_widget_destroy ( GTK_WIDGET ( socket ) ); return TCL_ERROR; } return gnoclRegisterWidget ( interp, GTK_WIDGET ( socket ), socketFunc ); }
int gnoclMenuSeparatorCmd( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret; GtkSeparatorMenuItem *separator; if( gnoclParseOptions( interp, objc - 1, objv + 1, separatorOptions ) != TCL_OK ) { gnoclClearOptions( separatorOptions ); return TCL_ERROR; } separator = GTK_SEPARATOR_MENU_ITEM( gtk_separator_menu_item_new( ) ); gtk_widget_show( GTK_WIDGET( separator ) ); /* gtk_widget_set_sensitive( GTK_WIDGET( para->menuItem ), 0 ); */ ret = gnoclSetOptions( interp, separatorOptions, G_OBJECT( separator ), -1 ); gnoclClearOptions( separatorOptions ); if( ret != TCL_OK ) { gtk_widget_destroy( GTK_WIDGET( separator ) ); return TCL_ERROR; } return gnoclRegisterWidget( interp, GTK_WIDGET( separator ), separatorFunc ); }
/** \brief Function associated with the widget. */ int gnoclEntryCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { #ifdef DEBUG_ENTRY printf ( "entry/staticFuncs/gnoclEntryCmd\n" ); #endif EntryParams *para; int ret; if ( gnoclParseOptions ( interp, objc, objv, entryOptions ) != TCL_OK ) { gnoclClearOptions ( entryOptions ); return TCL_ERROR; } para = g_new ( EntryParams, 1 ); para->entry = GTK_ENTRY ( gtk_entry_new( ) ); para->interp = interp; para->variable = NULL; para->onChanged = NULL; para->inSetVar = 0; gtk_entry_set_activates_default ( para->entry, TRUE ); gtk_widget_show ( GTK_WIDGET ( para->entry ) ); ret = gnoclSetOptions ( interp, entryOptions, G_OBJECT ( para->entry ), -1 ); if ( ret == TCL_OK ) { ret = configure ( interp, para, entryOptions ); } gnoclClearOptions ( entryOptions ); if ( ret != TCL_OK ) { gtk_widget_destroy ( GTK_WIDGET ( para->entry ) ); g_free ( para ); return TCL_ERROR; } para->name = gnoclGetAutoWidgetId(); g_signal_connect ( G_OBJECT ( para->entry ), "destroy", G_CALLBACK ( destroyFunc ), para ); gnoclMemNameAndWidget ( para->name, GTK_WIDGET ( para->entry ) ); Tcl_CreateObjCommand ( interp, para->name, entryFunc, para, NULL ); Tcl_SetObjResult ( interp, Tcl_NewStringObj ( para->name, -1 ) ); return TCL_OK; }
static int addItemTcl( ComboParams *para, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { GnoclOption addOption[] = { { "-value", GNOCL_OBJ, NULL }, /* 0 */ /* { "-icon", GNOCL_OBJ, NULL }, 1 */ { NULL } }; /* static const int addValueIdx = 0; */ int ret; /* id add text ? opt ...? */ if( objc < 3 ) { Tcl_WrongNumArgs( interp, 2, objv, "text ?option val ...?" ); return TCL_ERROR; } if( gnoclParseOptions( interp, objc - 2, objv + 2, addOption ) != TCL_OK ) { gnoclClearOptions( addOption ); return TCL_ERROR; } #if 0 ret = addItem( para, objv[2], addOption[addValueIdx].status == GNOCL_STATUS_CHANGED ? addOption[addValueIdx].val.obj : NULL ); #endif return ret; }
int gnoclMenuBarCmd( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret; GtkMenuBar *menuBar; if( gnoclParseOptions( interp, objc, objv, menuBarOptions ) != TCL_OK ) { gnoclClearOptions( menuBarOptions ); return TCL_ERROR; } menuBar = GTK_MENU_BAR( gtk_menu_bar_new( ) ); gtk_widget_show( GTK_WIDGET( menuBar ) ); ret = gnoclSetOptions( interp, menuBarOptions, G_OBJECT( menuBar ), -1 ); if( ret == TCL_OK ) ret = configure( interp, menuBar, menuBarOptions ); gnoclClearOptions( menuBarOptions ); if( ret != TCL_OK ) { gtk_widget_destroy( GTK_WIDGET( menuBar ) ); return TCL_ERROR; } return gnoclRegisterWidget( interp, GTK_WIDGET( menuBar ), menuBarFunc ); }
/** /brief /author William J Giddings **/ int gnoclFontButtonCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret; GtkFontButton *button; if ( gnoclParseOptions ( interp, objc, objv, fontButtonOptions ) != TCL_OK ) { gnoclClearOptions ( fontButtonOptions ); return TCL_ERROR; } button = GTK_FONT_BUTTON ( gtk_font_button_new( ) ); gtk_widget_show ( GTK_WIDGET ( button ) ); ret = gnoclSetOptions ( interp, fontButtonOptions, G_OBJECT ( button ), -1 ); gnoclClearOptions ( fontButtonOptions ); if ( ret != TCL_OK ) { gtk_widget_destroy ( GTK_WIDGET ( button ) ); return TCL_ERROR; } return gnoclRegisterWidget ( interp, GTK_WIDGET ( button ), fontButtonFunc ); }
/** \brief Description yet to be added. **/ int gnoclNotebookCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret; GtkWidget *widget; if ( gnoclParseOptions ( interp, objc, objv, notebookOptions ) != TCL_OK ) { gnoclClearOptions ( notebookOptions ); return TCL_ERROR; } widget = gtk_notebook_new(); ret = gnoclSetOptions ( interp, notebookOptions, G_OBJECT ( widget ), -1 ); if ( ret == TCL_OK ) ret = configure ( interp, GTK_NOTEBOOK ( widget ), notebookOptions ); gnoclClearOptions ( notebookOptions ); if ( ret != TCL_OK ) { gtk_widget_destroy ( widget ); return TCL_ERROR; } gtk_widget_show ( widget ); return gnoclRegisterWidget ( interp, widget, notebookFunc ); }
/** /brief /author William J Giddings /date 2008-08 **/ int gnoclDrawingAreaCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret; GtkWidget *widget; if ( gnoclParseOptions ( interp, objc, objv, drawingAreaOptions ) != TCL_OK ) { gnoclClearOptions ( drawingAreaOptions ); return TCL_ERROR; } widget = gtk_drawing_area_new (); gtk_widget_show ( GTK_WIDGET ( widget ) ); gnoclSetOptions ( interp, drawingAreaOptions, G_OBJECT ( widget ), -1 ); gnoclClearOptions ( drawingAreaOptions ); /* register the new widget for use with the Tcl interpretor */ return gnoclRegisterWidget ( interp, GTK_WIDGET ( widget ), drawingAreaFunc ); }
static int makeComboBox( Tcl_Interp *interp, int objc, Tcl_Obj * const objv[], int isEntry ) { ComboParams *para; GtkTreeModel *model; int ret; if( gnoclParseOptions( interp, objc, objv, boxOptions ) != TCL_OK ) { gnoclClearOptions( boxOptions ); return TCL_ERROR; } model = GTK_TREE_MODEL( gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF ) ); para = g_new( ComboParams, 1 ); para->interp = interp; para->onChanged = NULL; para->variable = NULL; para->name = gnoclGetAutoWidgetId(); para->comboBox = GTK_COMBO_BOX( isEntry ? gtk_combo_box_entry_new_with_model( model, VALUE_COLUMN ) : gtk_combo_box_new_with_model( model ) ); para->inSetVar = 0; if( isEntry == 0 ) { GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( para->comboBox ), renderer, TEXT_COLUMN ); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( para->comboBox ), renderer, "text", TEXT_COLUMN, NULL ); } gtk_widget_show( GTK_WIDGET( para->comboBox ) ); ret = gnoclSetOptions( interp, boxOptions, G_OBJECT( para->comboBox ), -1 ); if( ret == TCL_OK ) ret = configure( interp, para, boxOptions ); gnoclClearOptions( boxOptions ); if( ret != TCL_OK ) { gtk_widget_destroy( GTK_WIDGET( para->comboBox ) ); g_free( para ); return TCL_ERROR; } g_signal_connect( GTK_OBJECT( para->comboBox ), "destroy", G_CALLBACK( destroyFunc ), para ); gnoclMemNameAndWidget( para->name, GTK_WIDGET( para->comboBox ) ); Tcl_CreateObjCommand( interp, para->name, comboBoxFunc, para, NULL ); Tcl_SetObjResult( interp, Tcl_NewStringObj( para->name, -1 ) ); return TCL_OK; }
/** /brief /author Peter G Baum, William J Giddings **/ int gnoclTableCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret = TCL_OK; GtkTable *table; GtkFrame *frame = NULL; GtkWidget *widget; assert ( strcmp ( tableOptions[startFrameOpts].optName, "-label" ) == 0 ); assert ( strcmp ( tableOptions[startCommonOpts].optName, "-name" ) == 0 ); if ( gnoclParseOptions ( interp, objc, objv, tableOptions ) != TCL_OK ) { gnoclClearOptions ( tableOptions ); return TCL_ERROR; } table = GTK_TABLE ( gtk_table_new ( 1, 1, 0 ) ); if ( needFrame ( tableOptions ) ) { frame = GTK_FRAME ( gtk_frame_new ( NULL ) ); gtk_container_add ( GTK_CONTAINER ( frame ), GTK_WIDGET ( table ) ); widget = GTK_WIDGET ( frame ); } else widget = GTK_WIDGET ( table ); /* set default values */ gtk_table_set_row_spacings ( table, GNOCL_PAD_TINY ); gtk_table_set_col_spacings ( table, GNOCL_PAD ); gtk_container_set_border_width ( GTK_CONTAINER ( table ), GNOCL_PAD_TINY ); ret = configure ( interp, frame, table, tableOptions ); gnoclClearOptions ( tableOptions ); if ( ret != TCL_OK ) { gtk_widget_destroy ( widget ); return TCL_ERROR; } gtk_widget_show_all ( widget ); return gnoclRegisterWidget ( interp, widget, tableFunc ); }
int gnoclComboCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { ComboParams *para; int ret; if ( gnoclParseOptions ( interp, objc, objv, comboOptions ) != TCL_OK ) { gnoclClearOptions ( comboOptions ); return TCL_ERROR; } para = g_new ( ComboParams, 1 ); para->interp = interp; para->combo = GTK_COMBO ( gtk_combo_new( ) ); para->variable = NULL; para->onChanged = NULL; para->inSetVar = 0; ret = gnoclSetOptions ( interp, comboOptions, G_OBJECT ( para->combo ), -1 ); if ( ret == TCL_OK ) ret = configure ( interp, para, comboOptions ); gnoclClearOptions ( comboOptions ); if ( ret != TCL_OK ) { g_free ( para ); gtk_widget_destroy ( GTK_WIDGET ( para->combo ) ); return TCL_ERROR; } para->name = gnoclGetAutoWidgetId(); g_signal_connect ( G_OBJECT ( para->combo ), "destroy", G_CALLBACK ( destroyFunc ), para ); gnoclMemNameAndWidget ( para->name, GTK_WIDGET ( para->combo ) ); gtk_widget_show ( GTK_WIDGET ( para->combo ) ); Tcl_CreateObjCommand ( interp, para->name, comboFunc, para, NULL ); Tcl_SetObjResult ( interp, Tcl_NewStringObj ( para->name, -1 ) ); return TCL_OK; }
/** \brief \author \date **/ int gnoclFontSelectionCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret = TCL_OK; GtkWidget *widget; if ( gnoclParseOptions ( interp, objc, objv, fontSelectOptions ) != TCL_OK ) { gnoclClearOptions ( fontSelectOptions ); return TCL_ERROR; } widget = gtk_font_selection_new() ; gtk_widget_show ( GTK_WIDGET ( widget ) ); ret = gnoclSetOptions ( interp, fontSelectOptions, G_OBJECT ( widget ), -1 ); if ( ret == TCL_OK ) { ret = configure ( interp, G_OBJECT ( widget ), fontSelectOptions ); } gnoclClearOptions ( fontSelectOptions ); /* STEP 3) -show the widget */ if ( ret != TCL_OK ) { gtk_widget_destroy ( GTK_WIDGET ( widget ) ); return TCL_ERROR; } /* STEP 4) -everything has worked, register the widget with the Tcl interpretor. */ return gnoclRegisterWidget ( interp, GTK_WIDGET ( widget ), fontSelFunc ); return ret; }
int gnoclSpinButtonCmd( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { SpinButtonParams *para; if( gnoclParseOptions( interp, objc, objv, spinButtonOptions ) != TCL_OK ) { gnoclClearOptions( spinButtonOptions ); return TCL_ERROR; } para = g_new( SpinButtonParams, 1 ); para->spinButton = GTK_SPIN_BUTTON( gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, 0, 100, 1, 10, 20 ) ), 1.0, 1 ) ); para->interp = interp; para->variable = NULL; para->onValueChanged = NULL; para->inSetVar = 0; gtk_spin_button_set_numeric( para->spinButton, 1 ); gtk_widget_show( GTK_WIDGET( para->spinButton ) ); if( configure( interp, para, spinButtonOptions ) != TCL_OK ) { g_free( para ); gtk_widget_destroy( GTK_WIDGET( para->spinButton ) ); gnoclClearOptions( spinButtonOptions ); return TCL_ERROR; } gnoclClearOptions( spinButtonOptions ); para->name = gnoclGetAutoWidgetId(); g_signal_connect( G_OBJECT( para->spinButton ), "destroy", G_CALLBACK( spinButtonDestroyFunc ), para ); gnoclMemNameAndWidget( para->name, GTK_WIDGET( para->spinButton ) ); Tcl_CreateObjCommand( interp, para->name, spinButtonFunc, para, NULL ); Tcl_SetObjResult( interp, Tcl_NewStringObj( para->name, -1 ) ); return TCL_OK; }
/** \brief \author \date **/ int gnoclCalendarCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret = TCL_OK; GtkWidget *calendar; if ( 0 ) { if ( gnoclParseOptions ( interp, objc, objv, calendarOptions ) != TCL_OK ) { gnoclClearOptions ( calendarOptions ); return TCL_ERROR; } } calendar = gtk_calendar_new() ; gtk_widget_show ( GTK_WIDGET ( calendar ) ); if ( 0 ) { ret = gnoclSetOptions ( interp, calendarOptions, G_OBJECT ( calendar ), -1 ); if ( ret == TCL_OK ) { ret = configure ( interp, G_OBJECT ( calendar ), calendarOptions ); } gnoclClearOptions ( calendarOptions ); /* STEP 3) -show the widget */ if ( ret != TCL_OK ) { gtk_widget_destroy ( GTK_WIDGET ( calendar ) ); return TCL_ERROR; } } /* STEP 4) -everything has worked, register the widget with the Tcl interpretor. */ return gnoclRegisterWidget ( interp, GTK_WIDGET ( calendar ), calendarFunc ); }
/** \brief Function to create and configure an new instance of the button widget. **/ int gnoclButtonCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret; GtkButton *button; /* step 1) check validity of switches */ if ( gnoclParseOptions ( interp, objc, objv, buttonOptions ) != TCL_OK ) { gnoclClearOptions ( buttonOptions ); return TCL_ERROR; } /* step 2) create an instance of the widget and 'show' it*/ button = GTK_BUTTON ( gtk_button_new( ) ); gtk_widget_show ( GTK_WIDGET ( button ) ); /* step 3) check the options passed for the creation of the widget */ ret = gnoclSetOptions ( interp, buttonOptions, G_OBJECT ( button ), -1 ); /* step 4) if this is ok, then configure the new widget */ if ( ret == TCL_OK ) { ret = configure ( interp, button, buttonOptions ); } /* step 5) clear the memory set assigned to the options */ gnoclClearOptions ( buttonOptions ); /* step 6) if the options passed were incorrect, then delete the widget */ if ( ret != TCL_OK ) { gtk_widget_destroy ( GTK_WIDGET ( button ) ); return TCL_ERROR; } /* step 7) the process has been successful, so 'register' the widget with the interpreter */ return gnoclRegisterWidget ( interp, GTK_WIDGET ( button ), buttonFunc ); }
static int spinButtonFunc( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { static const char *cmds[] = { "delete", "configure", "cget", "onValueChanged", NULL }; enum cmdIdx { DeleteIdx, ConfigureIdx, CgetIdx, OnValueChangedIdx }; SpinButtonParams *para = (SpinButtonParams *)data; GtkWidget *widget = GTK_WIDGET( para->spinButton ); int idx; if( objc < 2 ) { Tcl_WrongNumArgs( interp, 1, objv, "command" ); return TCL_ERROR; } if( Tcl_GetIndexFromObj( interp, objv[1], cmds, "command", TCL_EXACT, &idx ) != TCL_OK ) return TCL_ERROR; switch( idx ) { case DeleteIdx: return gnoclDelete( interp, widget, objc, objv ); case ConfigureIdx: { int ret = TCL_ERROR; if( gnoclParseOptions( interp, objc - 1, objv + 1, spinButtonOptions ) == TCL_OK ) { ret = configure( interp, para, spinButtonOptions ); } gnoclClearOptions( spinButtonOptions ); return ret; } break; case CgetIdx: { int idx; switch( gnoclCget( interp, objc, objv, G_OBJECT( para->spinButton ), spinButtonOptions, &idx ) ) { case GNOCL_CGET_ERROR: return TCL_ERROR; case GNOCL_CGET_HANDLED: return TCL_OK; case GNOCL_CGET_NOTHANDLED: return cget( interp, para, spinButtonOptions, idx ); } } case OnValueChangedIdx: { if( objc != 2 ) { Tcl_WrongNumArgs( interp, 2, objv, NULL ); return TCL_ERROR; } return doCommand( para, getObjValue( para->spinButton ), 0 ); } } return TCL_OK; }
/** /brief /author Peter G Baum, William J Giddings **/ static int tableFunc ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { const char *cmds[] = { "delete", "configure", "add", "addRow", "addColumn", "class", NULL }; enum cmdIdx { DeleteIdx, ConfigureIdx, AddIdx, AddRowIdx, AddColumnIdx, ClassIdx }; int idx; GtkWidget *widget = GTK_WIDGET ( data ); GtkFrame *frame; GtkTable *table; if ( objc < 2 ) { Tcl_WrongNumArgs ( interp, 1, objv, "command" ); return TCL_ERROR; } if ( GTK_IS_FRAME ( widget ) ) { frame = GTK_FRAME ( widget ); table = GTK_TABLE ( gtk_bin_get_child ( GTK_BIN ( frame ) ) ); } else { frame = NULL; table = GTK_TABLE ( widget ); } /* For debugging purposes { guint rows, columns; g_object_get( G_OBJECT( table ), "n_rows", &rows, NULL ); g_object_get( G_OBJECT( table ), "n_columns", &columns, NULL ); printf( "rows: %d cols: %d\n", (int)rows, (int)columns ); } */ if ( Tcl_GetIndexFromObj ( interp, objv[1], cmds, "command", TCL_EXACT, &idx ) != TCL_OK ) return TCL_ERROR; switch ( idx ) { case ClassIdx: Tcl_SetObjResult ( interp, Tcl_NewStringObj ( "table", -1 ) ); break; case DeleteIdx: return gnoclDelete ( interp, widget, objc, objv ); case ConfigureIdx: { int ret = TCL_ERROR; if ( gnoclParseOptions ( interp, objc - 1, objv + 1, tableOptions ) == TCL_OK ) { ret = configure ( interp, frame, table, tableOptions ); } gnoclClearOptions ( tableOptions ); return ret; } break; case AddIdx: return tableFuncAdd ( table, interp, objc, objv ); case AddColumnIdx: case AddRowIdx: return addRowCol ( table, interp, objc, objv, idx == AddRowIdx ); } return TCL_OK; }
static int affine( Tcl_Interp *interp, int objc, Tcl_Obj * const objv[], CanvasParams *param, GPtrArray *items, int type ) { GnoclOption options[] = { { "-absolute", GNOCL_BOOL, NULL }, { "-reverseOrder", GNOCL_BOOL, NULL }, { NULL } }; static const int absoluteIdx = 0; static const int reverseOrderIdx = 1; guint m; int noCoords; int absolute = 0; int reverse = 0; if( objc < 4 ) { /* canvas (affine|move|scale|rotate) tag-or-id coords ?options ? */ Tcl_WrongNumArgs( interp, 3, objv, "list-of-coordinates ?option val ...?" ); return TCL_ERROR; } if( gnoclParseOptions( interp, objc - 3, objv + 3, options ) != TCL_OK ) return TCL_ERROR; if( options[absoluteIdx].status == GNOCL_STATUS_CHANGED ) absolute = options[absoluteIdx].val.b; if( options[reverseOrderIdx].status == GNOCL_STATUS_CHANGED ) reverse = options[reverseOrderIdx].val.b; gnoclClearOptions( options ); if( absolute && reverse ) { Tcl_SetResult( interp, "Options \"-reverseOrder\" is only valid " "for relative transformations.", TCL_STATIC ); return TCL_ERROR; } if( Tcl_ListObjLength( interp, objv[3], &noCoords ) != TCL_OK ) return TCL_ERROR; for( m = 0; m < items->len; ++m ) { Gnocl_CanvasItemInfo *info = GET_INFO( items, m ); int k; double af[6]; Tcl_Obj *tp; for( k = 0; k < 6 && k < noCoords; ++k ) { if( Tcl_ListObjIndex( interp, objv[3], k, &tp ) != TCL_OK ) return TCL_ERROR; if( Tcl_GetDoubleFromObj( interp, tp, &af[k] ) != TCL_OK ) return TCL_ERROR; } /* x' = af[0] * x + af[2] * y + af[4]; y' = af[1] * x + af[3] * y + af[5]; */ switch( type ) { case Affine: if( noCoords != 6 ) { Tcl_SetResult( interp, "size of list-of-coordinates must be 6", TCL_STATIC ); return TCL_ERROR; } break; case Move: if( noCoords != 2 ) { Tcl_SetResult( interp, "size of list-of-coordinates must " "be 2 (delta-x and delta-y)", TCL_STATIC ); return TCL_ERROR; } af[4] = af[0]; af[5] = af[1]; af[0] = 1.; af[2] = 0.; af[1] = 0.; af[3] = 1.; break; case Scale: if( noCoords != 3 && noCoords != 4 ) { Tcl_SetResult( interp, "size of list-of-coordinates must " "be 3 or 4 (center, x-scale and y-scale)", TCL_STATIC ); return TCL_ERROR; } else { double x = af[0]; double y = af[1]; double scalex = af[2]; double scaley = (noCoords == 4) ? af[3] : scalex; af[0] = scalex; af[2] = .0; af[4] = x * (1. - scalex); af[1] = .0; af[3] = scaley; af[5] = y * (1. - scaley); } break; case Rotate: /* there seems to be some problems with the canvas without antialiasing and rotating (bizarre drawings) */ if( noCoords != 3 ) { Tcl_SetResult( interp, "size of list-of-coordinates must " "be 3 (center and angle)", TCL_STATIC ); return TCL_ERROR; } else { double x = af[0]; double y = af[1]; double w = af[2]; const double cw = cos( w ); const double sw = sin( w ); af[0] = cw; af[2] = -sw; af[4] = x - x * cw + y * sw; af[1] = sw; af[3] = cw; af[5] = y - x * sw - y * cw; } break; } /* printf( "\nitem: %p absolute: %d\n", info->item, absolute ); printf( "before:\n" ); { int k; double af[6]; gnome_canvas_item_i2c_affine( info->item, af ); for( k = 0; k < 6; k += 2 ) printf( "%d: %f ", k, af[k] ); printf( "\n" ); for( k = 1; k < 6; k += 2 ) printf( "%d: %f ", k, af[k] ); printf( "\n" ); } printf( "affine:\n" ); for( k = 0; k < 6; k += 2 ) printf( "%d: %f ", k, af[k] ); printf( "\n" ); for( k = 1; k < 6; k += 2 ) printf( "%d: %f ", k, af[k] ); printf( "\n" ); */ if( absolute ) gnome_canvas_item_affine_absolute( info->item, af ); else { /* Well, *I* think this is a bug in gnome: affine_relative should not be the reverse of what one would expect. Or do I have wrong expectations? */ if( reverse ) gnome_canvas_item_affine_relative( info->item, af ); else { double bf[6]; gnome_canvas_item_i2w_affine( info->item, bf ); gnome_canvas_item_affine_absolute( info->item, af ); gnome_canvas_item_affine_relative( info->item, bf ); } } } return TCL_OK; }
/** /brief /author Peter G Baum, William J Giddings **/ static int tableFuncAdd ( GtkTable *table, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int row, column; char *childName; GtkWidget *childWidget; AttachOptions ao; /* default is expand, fill and shrink */ int ret = TCL_ERROR; if ( objc < 5 ) { Tcl_WrongNumArgs ( interp, 1, objv, "add widget column row ?option val ...?" ); return TCL_ERROR; } childName = Tcl_GetString ( objv[2] ); childWidget = gnoclGetWidgetFromName ( childName, interp ); if ( childWidget == NULL ) return TCL_ERROR; column = getIntOrEnd ( interp, table, objv[3], 0 ); if ( column < 0 ) return TCL_ERROR; row = getIntOrEnd ( interp, table, objv[4], 1 ); if ( row < 0 ) return TCL_ERROR; /* packOptions to skip startIdx */ if ( gnoclParseOptions ( interp, objc - 4, objv + 4, packOptions + 1 ) == TCL_OK ) ret = parsePackOptions ( interp, packOptions, &ao ); if ( ret == TCL_OK ) { if ( ao.useAlign ) { GtkWidget *alignment = gtk_alignment_new ( ao.xAlign, ao.yAlign, ao.xScale, ao.yScale ); /* alignment is deleted on deletion of childWidget only necessary, if not whole box is destroyed */ g_signal_connect ( G_OBJECT ( childWidget ), "destroy", G_CALLBACK ( alignDestroyFunc ), alignment ); gtk_container_add ( GTK_CONTAINER ( alignment ), childWidget ); gtk_widget_show ( alignment ); childWidget = alignment; } gtk_table_attach ( table, childWidget, column, column + ao.columnSpan, row, row + ao.rowSpan, ao.xOptions, ao.yOptions, ao.xPad, ao.yPad ); } return ret; }
/** \author Peter G. Baum **/ int gnoclClipboardCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { GnoclOption options[] = { { "-primary", GNOCL_BOOL, NULL }, { NULL } }; const int usePrimaryIdx = 0; static const char *cmd[] = { "hasText", "setText", "getText", "clear", NULL }; enum optIdx { HasTextIdx, SetTextIdx, GetTextIdx, ClearIdx }; int idx; int optNum; GtkClipboard *clip; int usePrimary = 0; if ( objc < 2 ) { Tcl_WrongNumArgs ( interp, 1, objv, "option" ); return TCL_ERROR; } if ( Tcl_GetIndexFromObj ( interp, objv[1], cmd, "option", TCL_EXACT, &idx ) != TCL_OK ) return TCL_ERROR; if ( idx == SetTextIdx ) { optNum = 2; if ( objc < 3 ) { Tcl_WrongNumArgs ( interp, 1, objv, "text ?option value?" ); return TCL_ERROR; } } else { optNum = 1; if ( objc < 2 ) { Tcl_WrongNumArgs ( interp, 1, objv, NULL ); return TCL_ERROR; } } if ( gnoclParseOptions ( interp, objc - optNum, objv + optNum, options ) != TCL_OK ) return TCL_ERROR; if ( options[usePrimaryIdx].status == GNOCL_STATUS_CHANGED ) usePrimary = options[usePrimaryIdx].val.b; clip = gtk_clipboard_get ( usePrimary ? gdk_atom_intern ( "PRIMARY", 1 ) : GDK_NONE ); switch ( idx ) { case HasTextIdx: { int ret = gtk_clipboard_wait_is_text_available ( clip ); Tcl_SetObjResult ( interp, Tcl_NewBooleanObj ( ret ) ); } break; case SetTextIdx: gtk_clipboard_set_text ( clip, Tcl_GetString ( objv[2] ), -1 ); break; case GetTextIdx: { char *txt = gtk_clipboard_wait_for_text ( clip ); if ( txt ) { Tcl_SetObjResult ( interp, Tcl_NewStringObj ( txt, -1 ) ); g_free ( txt ); } /* FIXME? else error? */ } break; case ClearIdx: gtk_clipboard_clear ( clip ); break; } return TCL_OK; }
int gnoclConfigureCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { GnoclOption options[] = { { "-tooltip", GNOCL_BOOL, NULL }, { "-defaultIcon", GNOCL_OBJ, NULL }, { NULL } }; const int tooltipIdx = 0; const int defaultIconIdx = 1; int ret = TCL_ERROR; if ( gnoclParseOptions ( interp, objc, objv, options ) != TCL_OK ) goto cleanExit; if ( options[defaultIconIdx].status == GNOCL_STATUS_CHANGED ) { GnoclStringType type = gnoclGetStringType ( options[defaultIconIdx].val.obj ); switch ( type ) { case GNOCL_STR_EMPTY: gtk_window_set_default_icon_list ( NULL ); break; case GNOCL_STR_FILE: { GdkPixbuf *pix = gnoclPixbufFromObj ( interp, options + defaultIconIdx ); GList *list = NULL; if ( pix == NULL ) goto cleanExit; list = g_list_append ( list, pix ); gtk_window_set_default_icon_list ( list ); g_list_free ( list ); } break; default: Tcl_AppendResult ( interp, "Unknown type for \"", Tcl_GetString ( options[defaultIconIdx].val.obj ), "\" must be of type FILE (%/) or empty", NULL ); goto cleanExit; } } if ( options[tooltipIdx].status == GNOCL_STATUS_CHANGED ) { if ( options[tooltipIdx].val.b ) gtk_tooltips_enable ( gnoclGetTooltips() ); else gtk_tooltips_disable ( gnoclGetTooltips() ); } ret = TCL_OK; cleanExit: gnoclClearOptions ( options ); return ret; }
int gnoclCanvasCmd( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { CanvasParams *para; int ret; if( gnoclParseOptions( interp, objc, objv, canvasOptions ) != TCL_OK ) { gnoclClearOptions( canvasOptions ); return TCL_ERROR; } para = g_new( CanvasParams, 1 ); /* what is that for? Found in canvas demos. */ gtk_widget_push_colormap( gdk_rgb_get_cmap() ); /* antialiased is default */ if( canvasOptions[antialiasedIdx].status == GNOCL_STATUS_CHANGED && canvasOptions[antialiasedIdx].val.b == 0 ) { para->canvas = GNOME_CANVAS( gnome_canvas_new( ) ); } else para->canvas = GNOME_CANVAS( gnome_canvas_new_aa( ) ); gtk_widget_show( GTK_WIDGET( para->canvas ) ); /* TODO: what is that for? Found in canvas demos. gtk_widget_pop_colormap(); */ gnome_canvas_set_center_scroll_region( para->canvas, 0 ); ret = gnoclSetOptions( interp, canvasOptions, G_OBJECT( para->canvas ), -1 ); if( ret == TCL_OK ) ret = configure( interp, para, canvasOptions ); gnoclClearOptions( canvasOptions ); if( ret != TCL_OK ) { gtk_widget_destroy( GTK_WIDGET( para->canvas ) ); g_free( para ); return TCL_ERROR; } para->name = gnoclGetAutoWidgetId(); gnoclMemNameAndWidget( para->name, GTK_WIDGET( para->canvas ) ); /* TODO: g_hash_table_new_full */ para->tagToItems = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, ptrArrayFree ); para->interp = interp; g_signal_connect_after( G_OBJECT( para->canvas ), "destroy", G_CALLBACK( destroyFunc ), para ); Tcl_CreateObjCommand( interp, para->name, canvasFunc, para, NULL ); Tcl_SetObjResult( interp, Tcl_NewStringObj( para->name, -1 ) ); return TCL_OK; }
/** /brief /author Peter G Baum, William J Giddings **/ static int addRowCol ( GtkTable *table, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[], int addRowFlag ) { int ret = TCL_ERROR; AttachOptions ao; int start = -1; if ( objc < 2 ) { /* id add{Row,Column} list ... */ Tcl_WrongNumArgs ( interp, 2, objv, "widget-list ?option val ...?" ); return TCL_ERROR; } if ( gnoclParseOptions ( interp, objc - 2, objv + 2, packOptions ) == TCL_OK ) { ret = parsePackOptions ( interp, packOptions, &ao ); if ( packOptions[startIdx].status == GNOCL_STATUS_CHANGED ) start = packOptions[startIdx].val.i; } gnoclClearOptions ( packOptions ); if ( ret == TCL_OK ) { int noChilds; int n; int column = 0, row = 0; if ( start >= 0 ) { if ( addRowFlag ) column = start; else row = start; } else { if ( addRowFlag ) row = getMaxRowCol ( table, 1 ); else column = getMaxRowCol ( table, 0 ); } if ( Tcl_ListObjLength ( interp, objv[2], &noChilds ) != TCL_OK || noChilds < 1 ) { Tcl_SetResult ( interp, "widget-list must be proper list", TCL_STATIC ); noChilds = 0; ret = TCL_ERROR; } for ( n = 0; n < noChilds; ++n ) { GtkWidget *childWidget; Tcl_Obj *tp; const char *childName; if ( Tcl_ListObjIndex ( interp, objv[2], n, &tp ) != TCL_OK ) { ret = TCL_ERROR; break; } /* TODO? if list object: options */ childName = Tcl_GetString ( tp ); /* empty widget-ID: skip this row/column */ if ( *childName ) { childWidget = gnoclChildNotPacked ( childName, interp ); if ( childWidget == NULL ) { ret = TCL_ERROR; break; } if ( ao.useAlign ) { GtkWidget *alignment = gtk_alignment_new ( ao.xAlign, ao.yAlign, ao.xScale, ao.yScale ); /* alignment is deleted on deletion of childWidget only necessary, if not whole box is destroyed */ g_signal_connect ( G_OBJECT ( childWidget ), "destroy", G_CALLBACK ( alignDestroyFunc ), alignment ); gtk_container_add ( GTK_CONTAINER ( alignment ), childWidget ); gtk_widget_show ( alignment ); childWidget = alignment; } gtk_table_attach ( table, childWidget, column, column + ao.columnSpan, row, row + ao.rowSpan, ao.xOptions, ao.yOptions, ao.xPad, ao.yPad ); } if ( addRowFlag ) column += ao.columnSpan; else row += ao.rowSpan; } } return ret; }
/****f* widget/gnoclLinkButtonCmd * AUTHOR * PGB * SOURCE */ int gnoclLinkButtonCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { int ret; GtkWidget *widget; int k, a, b; GnoclOption *pop; char *str_label, *str_uri ; /* determine which type of linkButton to create... */ /* * Do some pre-checking on the options set. * The gtk library has two forms of linkbutton, on with a label or one that simply shows the uri * these values are set at initialisation and so the argument line needs to be parsed so * that a decision can be made as to which type of widget to create. * */ /* * Parse all Options * Picking out individual options from the active script command line. */ for ( k = 1; k < objc; k += 2 ) { int idx; if ( gnoclGetIndexFromObjStruct ( interp, objv[k], ( char ** ) &linkButtonOptions[0].optName, sizeof ( GnoclOption ), "option", TCL_EXACT, &idx ) != TCL_OK ) { return -1; } /* originally, commented out */ /* printf( "parsing %s -> %s\n", Tcl_GetString( objv[k] ), linkButtonOptions[idx].optName); */ if ( strcmp ( Tcl_GetString ( objv[k] ), "-text" ) == 0 ) { str_label = Tcl_GetString ( objv[k+1] ); a = 1; } if ( strcmp ( Tcl_GetString ( objv[k] ), "-uri" ) == 0 ) { str_uri = Tcl_GetString ( objv[k+1] ); b = 1; } } /* decide what to do based on above values in step 2*/ /* STEP 1) -check validity of switches */ if ( gnoclParseOptions ( interp, objc, objv, linkButtonOptions ) != TCL_OK ) { gnoclClearOptions ( linkButtonOptions ); return TCL_ERROR; } /* STEP 2) -create widget, configure it, then clear memory */ /* * a== 1 and b == 1, then create a button with a label. * if a!= 1 and b == 1, then create a button with the URI as label * if b != 1, then this is an error. -uri is a mandatory option. */ if ( a == 1 && b == 1 ) { //printf ("label %s and URI %s\n", str_label, str_uri ); widget = GTK_WIDGET ( gtk_link_button_new_with_label ( str_uri, str_label ) ); } else if ( b == 1 ) { //printf ("URI %s\n", str_uri ); widget = gtk_link_button_new ( str_uri ); } else { //printf ("error\n" ); } a = 0; b = 0; gtk_widget_show ( GTK_WIDGET ( widget ) ); ret = gnoclSetOptions ( interp, linkButtonOptions, G_OBJECT ( widget ), -1 ); if ( ret == TCL_OK ) { ret = configure ( interp, G_OBJECT ( widget ), linkButtonOptions ); } gnoclClearOptions ( linkButtonOptions ); /* STEP 3) -show the widget */ if ( ret != TCL_OK ) { gtk_widget_destroy ( GTK_WIDGET ( widget ) ); return TCL_ERROR; } /* STEP 4) -everything has worked, register the widget with the Tcl interpretor. */ return gnoclRegisterWidget ( interp, GTK_WIDGET ( widget ), linkButtonFunc ); }
/** \brief \author Peter G Baum, William J Giddings \date **/ int gnoclLabelCmd ( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { #ifdef DEBUG_LABEL printf ( "label/staticFuncs/gnoclLabelCmd\n" ); #endif LabelParams *para; int ret; if ( gnoclParseOptions ( interp, objc, objv, labelOptions ) != TCL_OK ) { gnoclClearOptions ( labelOptions ); return TCL_ERROR; } para = g_new ( LabelParams, 1 ); para->label = GTK_LABEL ( gtk_label_new ( NULL ) ); para->interp = interp; para->textVariable = NULL; para->onChanged = NULL; para->inSetVar = 0; gtk_widget_show ( GTK_WIDGET ( para->label ) ); /* added 14/Jan/2010 */ gtk_label_set_use_markup ( para->label, TRUE ); ret = gnoclSetOptions ( interp, labelOptions, G_OBJECT ( para->label ), -1 ); if ( ret == TCL_OK ) { ret = configure ( interp, para, labelOptions ); } gnoclClearOptions ( labelOptions ); if ( ret != TCL_OK ) { gtk_widget_destroy ( GTK_WIDGET ( para->label ) ); g_free ( para ); return TCL_ERROR; } para->name = gnoclGetAutoWidgetId(); g_signal_connect ( G_OBJECT ( para->label ), "destroy", G_CALLBACK ( destroyFunc ), para ); gnoclMemNameAndWidget ( para->name, GTK_WIDGET ( para->label ) ); Tcl_CreateObjCommand ( interp, para->name, labelFunc, para, NULL ); Tcl_SetObjResult ( interp, Tcl_NewStringObj ( para->name, -1 ) ); return TCL_OK; }
/****f* callback/create * AUTHOR * PGB * SOURCE */ static int create ( Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { GnoclOption options[] = { { "-interval", GNOCL_OBJ, NULL }, /* 0 */ { "-priority", GNOCL_INT, NULL }, /* 1 */ { NULL } }; const int intervalIdx = 0; const int priorityIdx = 1; int interval = -1; int priority = 0; int id; GnoclCommandData *cs; if ( objc < 3 ) { Tcl_WrongNumArgs ( interp, 2, objv, "script" ); return TCL_ERROR; } if ( gnoclParseOptions ( interp, objc - 2, objv + 2, options ) != TCL_OK ) goto errorExit; if ( options[priorityIdx].status == GNOCL_STATUS_CHANGED ) priority = options[priorityIdx].val.i; /* TODO? test priority range? */ if ( options[intervalIdx].status == GNOCL_STATUS_CHANGED ) { Tcl_Obj * const obj = options[intervalIdx].val.obj; if ( Tcl_GetIntFromObj ( NULL, obj, &interval ) != TCL_OK ) { if ( strcmp ( Tcl_GetString ( obj ), "idle" ) != 0 ) { Tcl_AppendResult ( interp, "Expected integer or \"idle\", but got \"", Tcl_GetString ( obj ), "\"", NULL ); goto errorExit; } } else if ( interval <= 0 ) { Tcl_SetResult ( interp, "interval must be greater zero.", TCL_STATIC ); goto errorExit; } } gnoclClearOptions ( options ); cs = g_new ( GnoclCommandData, 1 ); cs->command = g_strdup ( Tcl_GetString ( objv[2] ) ); cs->interp = interp; if ( interval <= 0 ) /* idle */ { id = g_idle_add_full ( G_PRIORITY_DEFAULT_IDLE - priority, doCommand, cs, destroyCmd ); } else { id = g_timeout_add_full ( G_PRIORITY_DEFAULT_IDLE - priority, interval, doCommand, cs, destroyCmd ); } Tcl_SetObjResult ( interp, Tcl_NewIntObj ( id ) ); return TCL_OK; errorExit: gnoclClearOptions ( options ); return TCL_ERROR; }
static int canvasCreateItem( Tcl_Interp *interp, int objc, Tcl_Obj * const objv[], CanvasParams *param ) { const char *items[] = { "line", "rectangle", "ellipse", "bPath", "text", "richText", "widget", "image", "polygon", "clipGroup", NULL }; enum itemIdx { LineIdx, RectangleIdx, EllipseIdx, BPathIdx, TextIdx, RichTextIdx, WidgetIdx, ImageIdx, PolygonIdx, ClipGroupIdx }; static int noItems = 0; Gnocl_CanvasItemInfo *info; GnoclItemCreateFunc *func; int idx; int k; char buffer[64]; if( objc < 3 ) { Tcl_WrongNumArgs( interp, 2, objv, /* canvas create */ "type ?option val ...?" ); return TCL_ERROR; } if( Tcl_GetIndexFromObj( interp, objv[2], items, "item type", TCL_EXACT, &idx ) != TCL_OK ) return TCL_ERROR; switch( idx ) { case LineIdx: func = gnoclCanvasCreateLine; break; case RectangleIdx: func = gnoclCanvasCreateRectangle; break; case EllipseIdx: func = gnoclCanvasCreateEllipse; break; case BPathIdx: func = gnoclCanvasCreateBPath; break; case TextIdx: func = gnoclCanvasCreateText; break; case RichTextIdx: func = gnoclCanvasCreateRichText; break; case WidgetIdx: func = gnoclCanvasCreateWidget; break; case ImageIdx: func = gnoclCanvasCreateImage; break; case PolygonIdx: func = gnoclCanvasCreatePolygon; break; case ClipGroupIdx: func = gnoclCanvasCreateClipGroup; break; default: assert( 0 ); return TCL_ERROR; /* should never happen */ } info = (*func)( interp, objc, objv, gnome_canvas_root( param->canvas ) ); if( info == NULL ) return TCL_ERROR; gnoclParseOptions( NULL, 0, NULL, info->options ); g_object_set_data( G_OBJECT( info->item ), "gnocl::info", info ); info->id = ++noItems; info->tags = g_ptr_array_new( ); info->canvasParams = param; for( k = 0; k < GNOCL_CANVAS_ON_COUNT; ++k ) info->scripts[k] = NULL; sprintf( buffer, "%d", noItems ); gnoclCanvasAddTag( interp, param, info, buffer ); gnoclCanvasAddTag( interp, param, info, "all" ); gnoclClearOptions( info->options ); if( gnoclParseOptions( interp, objc - 2, objv + 2, info->options ) ) return TCL_ERROR; /* TODO: free all */ if( (*info->setOptions)( interp, info ) != TCL_OK ) return TCL_ERROR; /* TODO: free all */ gnoclClearOptions( info->options ); g_signal_connect( G_OBJECT( info->item ), "destroy", G_CALLBACK( destroyItemFunc ), info ); /* gnome_canvas_update_now( param->canvas ); */ Tcl_SetObjResult( interp, Tcl_NewIntObj( noItems ) ); return TCL_OK; }