自学教程：C++ CHECKOPT函数代码示例

/* Grabs the pointer (usually a mouse) so that all events are passed to this * application until the pointer is ungrabbed with gdk_pointer_ungrab(), or * the grab window becomes unviewable. This overrides any previous pointer * grab by this client. * Pointer grabs are used for operations which need complete control over mouse * events, even if the mouse leaves the application. For example in GTK+ it is * used for Drag and Drop, for dragging the handle in the GtkHPaned and GtkVPaned * widgets, and for resizing columns in GtkCList widgets. * Note that if the event mask of an X window has selected both button press and * button release events, then a button press event will cause an automatic pointer * grab until the button is released. X does this automatically since most * applications expect to receive button press and release events in pairs. * It is equivalent to a pointer grab on the window with owner_events set to TRUE. */intclip_GDK_POINTERGRAB(ClipMachine * ClipMachineMemory){   C_widget *cwin = _fetch_cw_arg(ClipMachineMemory);   GdkWindow *win = NULL;   gboolean  owner_events = _clip_parl(ClipMachineMemory, 2);   GdkEventMask event_mask = _clip_parnl(ClipMachineMemory, 3);   C_widget *cconfine_to = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 4));   GdkWindow *confine_to = NULL;   C_object *ccursor = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 5));   GdkCursor *cursor = NULL;   CHECKCWID(cwin, GTK_IS_WIDGET);   CHECKOPT(2, LOGICAL_type_of_ClipVarType);   CHECKOPT(3, NUMERIC_type_of_ClipVarType);   CHECKOPT2(4, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);   CHECKCWIDOPT(cwin, GTK_IS_WIDGET);   CHECKOPT2(5, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);   CHECKCOBJOPT(ccursor, GDK_IS_CURSOR(ccursor));   if (cwin && cwin->widget)      win = cwin->widget->window;   if (cconfine_to && cconfine_to->widget)      confine_to = cconfine_to->widget->window;   if (ccursor)      cursor = GDK_CURSOR(ccursor->object);   _clip_retni(ClipMachineMemory, gdk_pointer_grab(win, owner_events, event_mask, confine_to, cursor, GDK_CURRENT_TIME));   return 0; err:   return 1;}

/****  WINDOW constructor ****/intclip_GTK_WINDOWNEW(ClipMachine * ClipMachineMemory){   ClipVar  *cv = _clip_spar(ClipMachineMemory, 1);   char     *title = _clip_parc(ClipMachineMemory, 2);   gint      typ = INT_OPTION(ClipMachineMemory, 3, 0);   GtkWidget *wid = NULL;   C_widget *cwid;   CHECKOPT(1, MAP_type_of_ClipVarType);   CHECKOPT(2, CHARACTER_type_of_ClipVarType);   CHECKOPT(3, NUMERIC_type_of_ClipVarType);  //wid = gtk_window_new(GTK_WINDOW_TOPLEVEL);   wid = gtk_window_new(typ);   if (!wid)      goto err;   if (_clip_parinfo(ClipMachineMemory, 2) == CHARACTER_type_of_ClipVarType)    {       LOCALE_TO_UTF(title);       gtk_window_set_title(GTK_WINDOW(wid), title);       FREE_TEXT(title);    }  //cwid = (C_widget*)calloc( 1, sizeof(C_widget) );   cwid = _register_widget(ClipMachineMemory, wid, cv);   cwid->accel_group = gtk_accel_group_new();   gtk_window_add_accel_group(GTK_WINDOW(wid), cwid->accel_group);//      gtk_signal_connect( GTK_OBJECT( wid ), "delete-event",//              GTK_SIGNAL_FUNC( delete_window_handler ), NULL );   _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);   return 0; err:   return 1;}

/* Sets resize policy */intclip_GTK_WINDOWSETPOLICY(ClipMachine * ClipMachineMemory){   C_widget *cwin = _fetch_cw_arg(ClipMachineMemory);   gboolean  AutoShrink = FALSE, AllowShrink = TRUE, AllowGrow = TRUE;   CHECKOPT(2, LOGICAL_type_of_ClipVarType);   CHECKOPT(3, LOGICAL_type_of_ClipVarType);   CHECKOPT(4, LOGICAL_type_of_ClipVarType);   CHECKCWID(cwin, GTK_IS_WINDOW);   if (_clip_parinfo(ClipMachineMemory, 2) == LOGICAL_type_of_ClipVarType)      AutoShrink = _clip_parl(ClipMachineMemory, 2);   if (_clip_parinfo(ClipMachineMemory, 3) == LOGICAL_type_of_ClipVarType)      AllowGrow = _clip_parl(ClipMachineMemory, 3);   if (_clip_parinfo(ClipMachineMemory, 4) == LOGICAL_type_of_ClipVarType)      AllowShrink = _clip_parl(ClipMachineMemory, 4);   gtk_window_set_policy(GTK_WINDOW(cwin->widget), AllowShrink, AllowGrow, AutoShrink);   return 0; err:   return 1;}

/* Set the position of the separator, as if set by the user. If position is * negative, the remembered position is forgotten, and the division is * recomputed from the the requisitions of the children. */intclip_GTK_PANEDSETPOSITION(ClipMachine * cm){	C_widget  *cpan = _fetch_cw_arg(cm);	gint   position = _clip_parni(cm,2);	CHECKCWID(cpan,GTK_IS_PANED);	CHECKOPT(2,NUMERIC_t);	if (_clip_parinfo(cm,2)==UNDEF_t) position = -1;	gtk_paned_set_position(GTK_PANED(cpan->widget), position);	return 0;err:	return 1;}

/* Sets whether or not the connecting lines between branches and children are drawn. */intclip_GTK_TREESETVIEWLINES(ClipMachine * cm){	C_widget  *ctree = _fetch_cw_arg(cm);        gboolean    flag = _clip_parl(cm,2);        CHECKCWID(ctree,GTK_IS_TREE); CHECKOPT(2,LOGICAL_t);	gtk_tree_set_view_lines(GTK_TREE(ctree->widget), flag);	return 0;err:	return 1;}

/* A GtkProgress can be in one of two different modes: percentage mode (the default) * and activity mode. In activity mode, the progress is simply indicated as activity * rather than as a percentage complete. */intclip_GTK_PROGRESSSETACTIVITYMODE(ClipMachine * cm){	C_widget      *cprg = _fetch_cw_arg(cm);	guint activity_mode = _clip_parl(cm,2);        CHECKCWID(cprg,GTK_IS_PROGRESS);	CHECKOPT(2,LOGICAL_t);        if (_clip_parinfo(cm,2)==UNDEF_t) activity_mode = TRUE;        gtk_progress_set_activity_mode(GTK_PROGRESS(cprg->widget), activity_mode);	return 0;err:	return 1;}

/* Sets whether to show the bookmarks or not. */intclip_GTK_NOTEBOOKSETSHOWTABS(ClipMachine * cm){	C_widget     *cntb = _fetch_cw_arg(cm);	gboolean show_tabs = _clip_parl(cm,2);	CHECKCWID(cntb,GTK_IS_NOTEBOOK);	CHECKOPT(2,LOGICAL_t);	if (_clip_parinfo(cm,2)==UNDEF_t) show_tabs = TRUE;	gtk_notebook_set_show_tabs(GTK_NOTEBOOK(cntb->widget), show_tabs);	return 0;err:	return 1;}

/* Sets whether the bookmarks area may be scrollable or not if there are * too many bookmarks to fit in the allocated area. */intclip_GTK_NOTEBOOKSETSCROLLABLE(ClipMachine * cm){	C_widget      *cntb = _fetch_cw_arg(cm);	gboolean scrollable = _clip_parl(cm,2);	CHECKCWID(cntb,GTK_IS_NOTEBOOK);	CHECKOPT(2,LOGICAL_t);	if (_clip_parinfo(cm,2)==UNDEF_t) scrollable = TRUE;	gtk_notebook_set_scrollable(GTK_NOTEBOOK(cntb->widget), scrollable);	return 0;err:	return 1;}

/* Sets whether the tabs should have a vertical border. */intclip_GTK_NOTEBOOKSETTABVBORDER(ClipMachine * cm){	C_widget       *cntb = _fetch_cw_arg(cm);	gboolean tab_vborder = _clip_parl(cm,2);	CHECKCWID(cntb,GTK_IS_NOTEBOOK);	CHECKOPT(2,LOGICAL_t);	if (_clip_parinfo(cm,2)==UNDEF_t) tab_vborder = TRUE;	gtk_notebook_set_tab_vborder(GTK_NOTEBOOK(cntb->widget), tab_vborder);	return 0;err:	return 1;}

/* Sets whether the tabs must have all the same size or not. */intclip_GTK_NOTEBOOKSETHOMOGENEOUSTABS(ClipMachine * cm){	C_widget     *cntb = _fetch_cw_arg(cm);	guint  homogeneous = _clip_parl(cm,2);	CHECKCWID(cntb,GTK_IS_NOTEBOOK);	CHECKOPT(2,LOGICAL_t);	if (_clip_parinfo(cm,2)==UNDEF_t) homogeneous = TRUE;	gtk_notebook_set_homogeneous_tabs(GTK_NOTEBOOK(cntb->widget), homogeneous);	return 0;err:	return 1;}

/* Returns a map with fields RED, GREEN and BLUE */intclip_GDK_COLORRGB(ClipMachine * cm){	long RGB = _clip_parnl(cm,1);	CHECKOPT(1,NUMERIC_t);	if (_clip_parinfo(cm,1) != UNDEF_t)	{		ClipVar *ret = RETPTR(cm);		memset(ret, 0, sizeof(*ret)); _clip_map(cm, ret);		_clip_mputn(cm, ret, HASH_RED, (RGB & 0xFF) << 8);		_clip_mputn(cm, ret, HASH_GREEN, ((RGB >> 8) & 0xFF) << 8);		_clip_mputn(cm, ret, HASH_BLUE, ((RGB >> 16) & 0xFF) << 8);	}

/* If window is set modal, input will be grabbed when show and released when hide */intclip_GTK_WINDOWSETMODAL(ClipMachine * cm){	C_widget *cwin = _fetch_cw_arg(cm);	gboolean modal = _clip_parl(cm,2);	CHECKOPT(2,LOGICAL_t);	if (_clip_parinfo(cm,2) == UNDEF_t) modal = TRUE;	CHECKCWID(cwin,GTK_IS_WINDOW);	gtk_window_set_modal(GTK_WINDOW(cwin->widget), modal);	return 0;err:	return 1;}

/**** ACCEL LABEL constructor ****/intclip_GTK_ACCELLABELNEW(ClipMachine * cm){	ClipVar * cv   = _clip_spar(cm, 1);	char  * text   = _clip_parc(cm, 2);	GtkWidget *wid = NULL;	C_widget *cwid;	CHECKOPT(1,MAP_t);	CHECKOPT(2,CHARACTER_t);	LOCALE_TO_UTF(text);	wid = gtk_accel_label_new(text);	FREE_TEXT(text);	if (!wid) goto err;	cwid = _register_widget(cm, wid, cv);	_clip_mclone(cm,RETPTR(cm),&cwid->obj);	return 0;err:	return 1;}

/* Recomputes the entire curve using the given gamma value. A gamma value of 1 * results in a straight line. Values greater than 1 result in a curve above the * straight line. Values less than 1 result in a curve below the straight line. * The curve type is changed to GTK_CURVE_TYPE_FREE. */intclip_GTK_CURVESETGAMMA(ClipMachine * cm){	C_widget *ccur = _fetch_cw_arg(cm);        gfloat   gamma = _clip_parnd(cm,2);        CHECKCWID(ccur,GTK_CURVE);        CHECKOPT(2,NUMERIC_t);        if (_clip_parinfo(cm,2)==UNDEF_t) gamma = 1;        gtk_curve_set_gamma(GTK_CURVE(ccur->widget),gamma);	return 0;err:	return 1;}

/* Switches to the page number page_num. Negative values stand for the * last page; too large values are ignored. */intclip_GTK_NOTEBOOKSETPAGE(ClipMachine * cm){	C_widget   *cntb = _fetch_cw_arg(cm);	gint    page_num = _clip_parni(cm,2);	CHECKCWID(cntb,GTK_IS_NOTEBOOK);	CHECKOPT(2,NUMERIC_t);	if (_clip_parinfo(cm,2)==UNDEF_t) page_num = 1;	gtk_notebook_set_page(GTK_NOTEBOOK(cntb->widget), (page_num>0?page_num-1:page_num));	return 0;err:	return 1;}

intclip_GTK_CTREESETSHOWSTUB (ClipMachine *cm){	C_widget    *cctree = _fetch_cw_arg(cm);	gboolean show_stub  = _clip_parl(cm,2);	CHECKCWID(cctree,GTK_IS_CTREE);	CHECKOPT(2,LOGICAL_t);	if (_clip_parinfo(cm,2)==UNDEF_t) show_stub = 1;	gtk_ctree_set_show_stub (GTK_CTREE(cctree->widget), show_stub);	return 0;err:	return 1;}

intclip_GTK_COMBOSETPOPDOWNSTRINGS(ClipMachine * ClipMachineMemory){   C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory);   ClipArrVar *astr = (ClipArrVar *) _clip_vptr(_clip_spar(ClipMachineMemory, 2));   GList    *str_list = NULL;   gchar    *text_utf;   ClipStrVar *s;   int       i;   CHECKCWID(ccmb, GTK_IS_COMBO);   CHECKOPT(2, ARRAY_type_of_ClipVarType);   for (i = 0; i < astr->count; i++)    {       if (astr->items[i].t.ClipVartype_type_of_ClipType != CHARACTER_type_of_ClipVarType)	  continue;       s = (ClipStrVar *) _clip_vptr(&astr->items[i]);       text_utf = _clip_locale_to_utf8(s->str.buf);       if (ccmb->objtype == GTK_WIDGET_COMBO_SIMPLE)	{	   str_list = g_list_append(str_list, gtk_list_item_new_with_label(text_utf));	   g_free(text_utf);	}       else	  str_list = g_list_append(str_list, text_utf);    }   if (ccmb->objtype == GTK_WIDGET_COMBO_SIMPLE)    {       gtk_list_clear_items(GTK_LIST(GTK_COMBO(ccmb->widget)->list), 0, -1);       gtk_list_append_items(GTK_LIST(GTK_COMBO(ccmb->widget)->list), str_list);    }   else      gtk_combo_set_popdown_strings(GTK_COMBO(ccmb->widget), str_list);/*	while (str_list)	{		g_free(str_list->data);		str_list = g_list_next(str_list);	}*/   return 0; err:   return 1;}

/* Draws a number of characters in the given font or fontset. */intclip_GDK_DRAWTEXT(ClipMachine * ClipMachineMemory){   C_widget *cwid = _fetch_cw_arg(ClipMachineMemory);   C_object *cgc = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));   C_object *font = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3));   gint      x = _clip_parni(ClipMachineMemory, 4);   gint      y = _clip_parni(ClipMachineMemory, 5);   gchar    *text = _clip_parc(ClipMachineMemory, 6);   gint      length = _clip_parni(ClipMachineMemory, 7);   GdkDrawable *drw = NULL;   CHECKCWID(cwid, GTK_IS_WIDGET);   CHECKOPT2(2, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);   CHECKCOBJ(cgc, GDK_IS_GC(cgc));   CHECKOPT2(3, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);   CHECKCOBJ(cgc, GDK_IS_FONT(font));   CHECKOPT(4, NUMERIC_type_of_ClipVarType);   CHECKOPT(5, NUMERIC_type_of_ClipVarType);   CHECKOPT(6, CHARACTER_type_of_ClipVarType);   CHECKOPT(7, NUMERIC_type_of_ClipVarType);   drw = cwid->widget->window;   if (GTK_IS_PIXMAP(cwid->widget))      drw = GTK_PIXMAP(cwid->widget)->pixmap;   LOCALE_TO_UTF(text);   gdk_draw_text(drw, GDK_FONT(font->object), GDK_GC(cgc->object), x, y, text, length);   FREE_TEXT(text);   return 0; err:   return 1;}

/* Determines the location of the child widget with respect to the scrollbars. * The default is GTK_CORNER_TOP_LEFT, meaning the child is in the top left, * with the scrollbars underneath and to the right. Other values in GtkCornerType are * GTK_CORNER_TOP_RIGHT, GTK_CORNER_BOTTOM_LEFT, and GTK_CORNER_BOTTOM_RIGHT. */intclip_GTK_SCROLLEDWINDOWSETPLACEMENT(ClipMachine * ClipMachineMemory){   C_widget *csw = _fetch_cw_arg(ClipMachineMemory);   int       placement = _clip_parni(ClipMachineMemory, 2);   CHECKOPT(2, NUMERIC_type_of_ClipVarType);   CHECKCWID(csw, GTK_IS_SCROLLED_WINDOW);   gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(csw->widget), placement);   return 0; err:   return 1;}

/* Sets whether there should be a border around the bookmarks or not. */intclip_GTK_NOTEBOOKSETTABBORDER(ClipMachine * ClipMachineMemory){   C_widget *cntb = _fetch_cw_arg(ClipMachineMemory);   guint     border_width = _clip_parl(ClipMachineMemory, 2);   CHECKCWID(cntb, GTK_IS_NOTEBOOK);   CHECKOPT(2, NUMERIC_type_of_ClipVarType);   gtk_notebook_set_tab_border(GTK_NOTEBOOK(cntb->widget), border_width);   return 0; err:   return 1;}

intclip_GTK_CALENDARUNMARKDAY(ClipMachine * ClipMachineMemory){   C_widget *ccal = _fetch_cw_arg(ClipMachineMemory);   guint     day = _clip_parni(ClipMachineMemory, 2);   CHECKCWID(ccal, GTK_IS_CALENDAR);   CHECKOPT(2, NUMERIC_type_of_ClipVarType);   gtk_calendar_unmark_day(GTK_CALENDAR(ccal->widget), day);   return 0; err:   return 1;}

/* Set where the text within the GtkLabel will align to. This can be one of four * values: GTK_JUSTIFY_LEFT, GTK_JUSTIFY_RIGHT, GTK_JUSTIFY_CENTER, and * GTK_JUSTIFY_FILL. GTK_JUSTIFY_CENTER is the default value when the widget is * first created with gtk_label_new(). */intclip_GTK_LABELSETJUSTIFY(ClipMachine * ClipMachineMemory){   C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);   GtkJustification jtype = _clip_parni(ClipMachineMemory, 2);   CHECKCWID(clbl, GTK_IS_LABEL);   CHECKOPT(2, NUMERIC_type_of_ClipVarType);   gtk_label_set_justify(GTK_LABEL(clbl->widget), jtype);   return 0; err:   return 1;}

intclip_GTK_MENUSHELLACTIVATETITEM(ClipMachine * cm){	C_widget *cmns = _fetch_cw_arg(cm);	C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));        gboolean force_deactivate = _clip_parl(cm,3);        CHECKCWID(cmns,GTK_IS_MENU_SHELL);	CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);        CHECKOPT(3,LOGICAL_t);        gtk_menu_shell_activate_item(GTK_MENU_SHELL(cmns->widget), cwid->widget, force_deactivate);	return 0;err:	return 1;}

intclip_GTK_MENUSHELLINSERT(ClipMachine * cm){	C_widget *cmns = _fetch_cw_arg(cm);	C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));        int   position = _clip_parni(cm,3);        CHECKCWID(cmns,GTK_IS_MENU_SHELL);	CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);        CHECKOPT(3,NUMERIC_t);        gtk_menu_shell_insert(GTK_MENU_SHELL(cmns->widget), cwid->widget, position);	return 0;err:	return 1;}

/* The pattern of underlines you want under the existing text within the GtkLabel * widget. For example if the current text of the label says "FooBarBaz" passing * a pattern of "___ ___" will underline "Foo" and "Baz" but not "Bar".  */intclip_GTK_LABELSETPATTERN(ClipMachine * ClipMachineMemory){   C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);   char     *pattern = _clip_parc(ClipMachineMemory, 2);   CHECKCWID(clbl, GTK_IS_LABEL);   CHECKOPT(2, CHARACTER_type_of_ClipVarType);   gtk_label_set_pattern(GTK_LABEL(clbl->widget), pattern);   return 0; err:   return 1;}

/* This function is unimplemented because tooltip colors are * instead determined by the theme. */intclip_GTK_TOOLTIPSSETCOLORS(ClipMachine * ClipMachineMemory){   C_widget *ctt = _fetch_cw_arg(ClipMachineMemory);   ClipVar  *mback = _clip_spar(ClipMachineMemory, 2);   ClipVar  *mfore = _clip_spar(ClipMachineMemory, 3);   GdkColor  back, fore, *pback = NULL, *pfore = NULL;   CHECKCWID(ctt, GTK_IS_TOOLTIPS);   CHECKOPT(2, MAP_type_of_ClipVarType);   CHECKOPT(3, MAP_type_of_ClipVarType);   if (mback && mback->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == MAP_type_of_ClipVarType)      _map_colors_to_gdk(ClipMachineMemory, mback, pback = &back);   if (mfore && mfore->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType == MAP_type_of_ClipVarType)      _map_colors_to_gdk(ClipMachineMemory, mfore, pfore = &fore);   gtk_tooltips_set_colors(GTK_TOOLTIPS(ctt->widget), pback, pfore);   return 0; err:   return 1;}

/* Toggles line wrapping within the GtkLabel widget. TRUE makes it break lines * if text exceeds the widget's size. FALSE lets the text get cut off by the * edge of the widget if it exceeds the widget size. */intclip_GTK_LABELSETLINEWRAP(ClipMachine * ClipMachineMemory){   C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);   gboolean  wrap = _clip_parl(ClipMachineMemory, 2);   CHECKCWID(clbl, GTK_IS_LABEL);   CHECKOPT(2, LOGICAL_type_of_ClipVarType);   gtk_label_set_line_wrap(GTK_LABEL(clbl->widget), wrap);   return 0; err:   return 1;}

/* Sets the time between the user moving the mouse over a widget and * the widget's tooltip appearing. */intclip_GTK_TOOLTIPSSETDELAY(ClipMachine * ClipMachineMemory){   C_widget *ctt = _fetch_cw_arg(ClipMachineMemory);   guint     delay = _clip_parni(ClipMachineMemory, 2);   CHECKCWID(ctt, GTK_IS_TOOLTIPS);   CHECKOPT(2, NUMERIC_type_of_ClipVarType);   gtk_tooltips_set_delay(GTK_TOOLTIPS(ctt->widget), delay);   return 0; err:   return 1;}