C++ DoMethod函数代码示例

static IPTR mDispose(struct IClass *cl, Object *obj, Msg msg)
{
    struct data       *data = INST_DATA(cl,obj);
    struct DiskObject *icon = data->icon;
    IPTR              res;

    /*
    ** Because of users hate an app that saves on disc
    ** at any exit, we check if you must save something
    */
    if (DoMethod(data->win,MUIM_App_CheckSave))
    {
        DoSuperMethod(cl,obj,MUIM_Application_Save,(IPTR)MUIV_Application_Save_ENV);
        DoSuperMethod(cl,obj,MUIM_Application_Save,(IPTR)MUIV_Application_Save_ENVARC);
    }

    res = DoSuperMethodA(cl,obj,msg);

    if (icon) FreeDiskObject(icon);

    return res;
}

VOID ImageDecoderThread ()
{
	LONG args[6];
	struct RDArgs *readargs;
	if(readargs = ReadArgs("/A/N,/A/N,/A/N,/A/N,/A/N,/A/F", args, NULL))
	{
		ULONG pageID = *((ULONG *)args[0]);
		struct ImageList *images = *((struct ImageList **)args[1]);
		Object *ipc = *((Object **)args[2]);
		ULONG handle = *((ULONG *)args[3]);
		struct Screen *scr = *((struct Screen **)args[4]);
		STRPTR url = (STRPTR)args[5];

		Object *dt = NULL;
		if(dt = NewDTObject(url,
			DTA_GroupID,				GID_PICTURE,
			PDTA_DestMode,				MODE_V43,
			PDTA_Remap,					TRUE,
			PDTA_FreeSourceBitMap,	TRUE,
			PDTA_Screen,				scr,
			PDTA_UseFriendBitMap,	TRUE,
			TAG_DONE))
		{
			DoMethod(dt, DTM_PROCLAYOUT);
		}

		struct IPCMsg ipcmsg(handle, IPCFlg_Unlock);
		ipcmsg.MethodID				= MUIM_IPC_DoMessage;
		ipcmsg.PageID					= pageID;
		ipcmsg.Images					= images;
		ipcmsg.DTObject				= dt;
		ipcmsg.ImageDecoderThread	= FindTask(NULL);

		if(!DoMethodA(ipc, (Msg)&ipcmsg))
			DisposeDTObject(dt);

		UnlockPubScreen(NULL, scr);
	}
}

/*
 * Create an object from a class.
 */
Object *
NewObjectA (struct IClass  *classPtr,
	    ClassID         classID,
	    struct TagItem *tagList)
{
    Object * object;
    struct _Object carrier;

    /* No classPtr ? */
    if (!classPtr)
    {
        /* Search for the class */
        if (!(classPtr = GetPublicClass(classID)) )
        {
	    /* I used to have a last-resort builtin class creation here,
	     * but I decided nobody should need it, because you
	     * dont have to call this function with a non-public class -dlc
	     */
	    g_error("NewObjectA: null classPtr, and non public class %s\n"
		    "Perhaps you should try MUI_NewObjectA ?\n",
		    classID);
	    return (NULL); /* Nothing found */
        }
    }

    /* Put the classPtr in our dummy object */
    carrier.o_Class = classPtr;

    /* Try to create a new object */
    if ((object = (Object *) DoMethod (BASEOBJECT(&carrier), OM_NEW, (ULONG)tagList)))
    {
	OCLASS(object) = classPtr;

	/* One more object */
	classPtr->cl_ObjectCount ++;
    }

    return (object);
} /* NewObjectA */

static APTR build_drive_gui(void)
{
  APTR app, ui, ok, cancel;

  app = mui_get_app();

  ui = GroupObject,
    FILENAME(ui_to_from_drive[0].object, "2031", hook_object_drive[0])
    FILENAME(ui_to_from_drive[1].object, "2030", hook_object_drive[1])
    FILENAME(ui_to_from_drive[2].object, "3040", hook_object_drive[2])
    FILENAME(ui_to_from_drive[3].object, "4040", hook_object_drive[3])
    FILENAME(ui_to_from_drive[4].object, "1001", hook_object_drive[4])
    OK_CANCEL_BUTTON
  End;

  if (ui != NULL) {
    DoMethod(cancel,
      MUIM_Notify, MUIA_Pressed, FALSE,
      app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);

    DoMethod(ok, MUIM_Notify, MUIA_Pressed, FALSE,
      app, 2, MUIM_Application_ReturnID, BTN_OK);

    DoMethod(hook_object_drive[0], MUIM_Notify, MUIA_Pressed, FALSE,
      app, 2, MUIM_CallHook, &BrowseDrive0);

    DoMethod(hook_object_drive[1], MUIM_Notify, MUIA_Pressed, FALSE,
      app, 2, MUIM_CallHook, &BrowseDrive1);

    DoMethod(hook_object_drive[2], MUIM_Notify, MUIA_Pressed, FALSE,
      app, 2, MUIM_CallHook, &BrowseDrive2);

    DoMethod(hook_object_drive[3], MUIM_Notify, MUIA_Pressed, FALSE,
      app, 2, MUIM_CallHook, &BrowseDrive3);

    DoMethod(hook_object_drive[4], MUIM_Notify, MUIA_Pressed, FALSE,
      app, 2, MUIM_CallHook, &BrowseDrive4);
  }

  return ui;
}

///
/// US_OpenFunc
//  Opens and initializes user list window
HOOKPROTONHNONP(US_OpenFunc, void)
{
  ENTER();

  if(G->US == NULL)
  {
    struct User *user = US_GetCurrentUser();

    // if the first user doesn't have a real name yet then copy over the name from the configuration
    if(G->Users.User[0].Name[0] == '\0')
    {
      struct UserIdentityNode *uin = GetUserIdentity(&C->userIdentityList, 0, TRUE);

      if(uin != NULL)
        strlcpy(G->Users.User[0].Name, uin->realname, sizeof(G->Users.User[0].Name));
    }

    if((G->US = US_New(!user->Limited)) != NULL)
    {
      if(SafeOpenWindow(G->US->GUI.WI))
      {
        int i;

        // add the users to the listview
        for(i = 0; i < G->Users.Num; i++)
          DoMethod(G->US->GUI.LV_USERS, MUIM_NList_InsertSingle, &G->Users.User[i], MUIV_NList_Insert_Bottom);

        set(G->US->GUI.LV_USERS, MUIA_NList_Active, 0);
        set(G->US->GUI.BT_ADD, MUIA_Disabled, G->Users.Num == MAXUSERS);
        set(G->US->GUI.BT_DEL, MUIA_Disabled, G->Users.Num == 0);
      }
      else
        DisposeModulePush(&G->US);
    }
  }

  LEAVE();
}

VOID RedrawPreview( FRAME *pwframe, EXTBASE *PPTBase )
{
    D(bug("RedrawPreview( %08X, xb=%08X )\n",pwframe, PPTBase ));

    if( pwframe->preview.pf_Hook ) {
        CallHook( pwframe->preview.pf_Hook, (Object *)pwframe, ~0 );
    } else {
        /*
         *  Send message to the main window
         */
        struct IBox *ibox;

        GetAttr(AREA_AreaBox, pwframe->preview.pf_RenderArea, (ULONG *)&ibox );
        QuickRender( pwframe, pwframe->preview.pf_win->RPort,
                     ibox->Top, ibox->Left,
                     ibox->Height, ibox->Width, PPTBase );

#if 0
        DoMethod( pwframe->parent->disp->Win, WM_REPORT_ID, GID_DW_AREA,
                  WMRIF_TASK, globals->maintask, TAG_DONE );
#endif
    }
}

static void closeAllWindows(Object *app)
{
  BOOL loop;

  ENTER();

  do
  {
    struct List *list;
    Object *mstate;
    Object *win;

    loop = FALSE;

    list = (struct List *)xget(app, MUIA_Application_WindowList);
    mstate = (Object *)list->lh_Head;

    while((win = NextObject(&mstate)) != NULL)
    {
      ULONG ok = FALSE;

      ok = xget(win, MUIA_App_IsSubWin);
      if(ok)
      {
        set(win, MUIA_Window_Open, FALSE);
        DoMethod(app, OM_REMMEMBER, (IPTR)win);
        MUI_DisposeObject(win);
        loop = TRUE;
        break;
      }
    }
  }
  while(loop == TRUE);

  LEAVE();
}

VOID TextAreaClass::AppendGadget (struct AppendGadgetMessage &amsg)
{
  if(Flags & FLG_AllElementsPresent)
  {
    if(!MUIGadget)
    {
      MUIGadget = TextEditorObject,
        MUIA_TextEditor_Rows, Rows,
        MUIA_TextEditor_Columns, Columns,
/*        MUIA_FixWidth, 400,
        MUIA_FixHeight, 200,
*/        MUIA_TextEditor_InVirtualGroup, TRUE,
        MUIA_TextEditor_Contents, Contents,
        MUIA_TextEditor_FixedFont, TRUE,
        MUIA_TextEditor_ReadOnly, Flags & FLG_TextArea_ReadOnly,
        MUIA_CycleChain, TRUE,
        End;

      if(MUIGadget)
          DoMethod(amsg.Parent, OM_ADDMEMBER, (ULONG)MUIGadget);
      else  Flags |= FLG_Layouted;
    }
  }
}

static void GUINewSettings(void) {
  Object *oldcycle;
  Object *cycle = CycleObject,
      CYC_Labels,    Units,
      CYC_Active,    state.UnitSelected,
      CYC_PopActive, PopUpMenus,
      CYC_Popup,     PopUpMenus,
      GA_ID,         ACTID_UNIT,
  EndObject;

  if(cycle) {
    oldcycle = (Object *) DoMethod( vgroup, GRM_REPLACEMEMBER,
      Window_Objs[ACTID_UNIT], cycle, FixMinHeight, TAG_DONE);
    if(oldcycle) {
      DisposeObject(oldcycle);
      Window_Objs[ACTID_UNIT] = cycle;
    }
    else {
      DisposeObject(cycle);
    }
  }

  SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_DEBUG], window, NULL,
      CYC_Active, globalprefs.ahigp_DebugLevel, TAG_DONE);
  SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_SURROUND], window, NULL,
      CYC_Active, globalprefs.ahigp_DisableSurround, TAG_DONE);
  SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_ECHO], window, NULL,
      CYC_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) | 
                  (globalprefs.ahigp_FastEcho    ? 1 : 0),     TAG_DONE);
  SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_CLIPMV], window, NULL,
      CYC_Active, globalprefs.ahigp_ClipMasterVolume, TAG_DONE);
  SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_CPULIMIT], window, NULL,
      SLIDER_Level, (globalprefs.ahigp_MaxCPU * 100 + 32768) >> 16, TAG_DONE);

  GUINewUnit();
}

static void DisposeObj(Object *o, SW_IDATA *idata)
{
   DoMethod(idata->SWA_NNews_GlobSel,  SWM_NSFilter_HideUI);
   DoMethod(idata->SWA_NNews_GlobHL,   SWM_NSFilter_HideUI);
   DoMethod(idata->SWA_NNews_GlobKill, SWM_NSFilter_HideUI);
   DoMethod(idata->SWA_NNews_GlobDsp,  SWM_NDFilter_HideUI);
   DoMethod(idata->SWA_NNews_GlobAct,  SWM_NAFilter_HideUI);
   MUI_DisposeObject(idata->ArtLst);

   //  -- close all our windows ----------------------------------------------

   CloseAll(o, idata, SWV_WinMax, TRUE);
   ClrLists(idata);

   DoMethod(idata->DTImg, SWM_DTImg_FreeImgCache, idata->SWA_NNews_DTImages);

   MUI_DisposeObject(idata->DTImg);

   // -- so objs don`t try to talk to the application object during dispose --

   set(o, SWA_AppBase_App, NULL);

}

struct WCSScreenMode *ModeList_Choose(struct WCSScreenMode *This,
 struct WCSScreenData *ScrnData)
{
static const char *Cycle_OSCAN[] = {"None", "Text", "Standard", "Max", "Video", NULL};
struct WCSScreenMode *Scan, *Selected;
APTR ModeSelWin, SM_Save, SM_Use, SM_Exit, SM_Width, SM_Height, SM_List, SM_Text, SM_OSCAN;
ULONG Signalz, Finished, ReturnID;
int CheckVal, Update;
char *ModeText, ModeInfo[255];

ModeSelWin = WindowObject,
 MUIA_Window_Title, "World Construction Set Screenmode",
 MUIA_Window_ID, "SCRN",
 MUIA_Window_SizeGadget, TRUE,
 WindowContents, VGroup,
  Child, ColGroup(2), MUIA_Group_SameWidth, TRUE,
    MUIA_Group_HorizSpacing, 4, MUIA_Group_VertSpacing, 3,
   Child, VGroup, /* MUIA_HorizWeight, 150, */
    Child, TextObject, MUIA_Text_Contents, "\33cDisplay Mode", End,
    Child, SM_List = ListviewObject,
     MUIA_Listview_Input, TRUE,
     MUIA_Listview_List, ListObject, ReadListFrame, End,
     End,
    End,
   Child, VGroup,
    Child, TextObject, MUIA_Text_Contents, "\33cMode Information", End,
    Child, SM_Text = FloattextObject, ReadListFrame,
     MUIA_Floattext_Text, "Mode:           \nRes :                      \nAuto:            \nScan:                   \n\nAttributes\n\n\n", End,
    End,
   Child, HGroup,
    Child, Label2("Overscan: "),
    Child, SM_OSCAN = CycleObject, MUIA_Cycle_Entries, Cycle_OSCAN, End,
    End,
   Child, HGroup,
    Child, RectangleObject, End,
    Child, HGroup, MUIA_Group_HorizSpacing, 0,
     Child, Label2("Width "), /* No End (in sight) */
     Child, SM_Width = StringObject, StringFrame,
      MUIA_String_Integer, 0,
      MUIA_String_Accept, "0123456789",
      MUIA_FixWidthTxt, "01234",
      End,
     End,
    Child, RectangleObject, End,
    Child, HGroup, MUIA_Group_HorizSpacing, 0,
     Child, Label2("Height "), /* No End (in sight) */
     Child, SM_Height = StringObject, StringFrame,
      MUIA_String_Integer, 0,
      MUIA_String_Accept, "0123456789",
      MUIA_FixWidthTxt, "01234",
      End,
     End,
    Child, RectangleObject, End,
    End,
   End,
  Child, RectangleObject, MUIA_FixHeight, 4, End,
  Child, HGroup, MUIA_HorizWeight, 1,
   /* Button button button. Who's got the button? */
   MUIA_Group_SameSize, TRUE,
   Child, SM_Save = KeyButtonObject('s'), MUIA_Text_Contents, "\33cSave", MUIA_HorizWeight, 200, End,
   Child, RectangleObject, MUIA_HorizWeight, 1, End,
   Child, SM_Use  = KeyButtonObject('u'), MUIA_Text_Contents, "\33cUse", MUIA_HorizWeight, 200, End,
   Child, RectangleObject, MUIA_HorizWeight, 1, End,
   Child, SM_Exit = KeyButtonObject('e'), MUIA_Text_Contents, "\33cExit", MUIA_HorizWeight, 200, End,
   End,
  End,
 End;

if(ModeSelWin)
 {
 DoMethod(ModeSelWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  app, 2, MUIM_Application_ReturnID, ID_SM_EXIT);

 MUI_DoNotiPresFal(app, SM_Exit, ID_SM_EXIT,
  SM_Use, ID_SM_USE, SM_Save, ID_SM_SAVE, NULL);
 
 DoMethod(SM_List, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
  app, 2, MUIM_Application_ReturnID, ID_SM_LIST);
 DoMethod(SM_OSCAN, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
  app, 2, MUIM_Application_ReturnID, ID_SM_OSCAN);
 DoMethod(SM_Width, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  app, 2, MUIM_Application_ReturnID, ID_SM_WIDTH);
 DoMethod(SM_Height, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
  app, 2, MUIM_Application_ReturnID, ID_SM_HEIGHT);

 DoMethod(ModeSelWin, MUIM_Window_SetCycleChain,
  SM_List, SM_Save, SM_Use, SM_Exit, SM_OSCAN, SM_Width, SM_Height, NULL);

 set(ModeSelWin, MUIA_Window_ActiveObject, SM_Save);

 for(Scan = This; Scan; Scan = Scan->Next)
  {
  DoMethod(SM_List, MUIM_List_InsertSingle, Scan->ModeName, MUIV_List_Insert_Sorted);
  } /* for */
 
 set(SM_List, MUIA_List_Active, MUIV_List_Active_Top);

 DoMethod(app, OM_ADDMEMBER, ModeSelWin);
#ifdef WCS_MUI_2_HACK
/* This is not needed here, but will be when ScreenMode selection
//.........这里部分代码省略.........

//.........这里部分代码省略.........
								Child, filter_remote_check = MakeCheck(NULL,FALSE),
								Child, RectangleObject,MUIA_Weight,200,End,
								Child, MakeLabel(_("On new mails")),
								Child, filter_new_check = MakeCheck(NULL,FALSE),
								End,
							Child, RectangleObject,MUIA_Weight,25,End,
							End,
						Child, HorizLineTextObject(_("Rules")),
						Child, VGroupV,
							Child, filter_rule_group = ColGroup(2),
								Child, HVSpace,
								Child, HVSpace,
								End,
							End,
						Child, HGroup,
							Child, filter_add_rule_button = MakeButton(_("Add new rule")),
							Child, filter_apply_now_button = MakeButton(_("Apply now")),
							End,
						Child, HorizLineTextObject(_("Action")),
						Child, VGroup,
							Child, ColGroup(3),
								Child, MakeLabel(_("Move to Folder")),
								Child, filter_move_check = MakeCheck(_("Move to Folder"),FALSE),
								Child, filter_move_popobject = PopobjectObject,
									MUIA_Disabled, TRUE,
									MUIA_Popstring_Button, PopButton(MUII_PopUp),
									MUIA_Popstring_String, filter_move_text = TextObject, TextFrame, MUIA_Background, MUII_TextBack, End,
									MUIA_Popobject_ObjStrHook, &move_objstr_hook,
									MUIA_Popobject_StrObjHook, &move_strobj_hook,
									MUIA_Popobject_Object, NListviewObject,
										MUIA_NListview_NList, filter_folder_list = FolderTreelistObject,
											End,
										End,
									End,

								Child, MakeLabel(_("Execute ARexx Script")),
								Child, filter_arexx_check = MakeCheck(_("Execute ARexx Script"),FALSE),
								Child, filter_arexx_popasl = PopaslObject,
									MUIA_Disabled, TRUE,
									MUIA_Popstring_Button, PopButton(MUII_PopFile),
									MUIA_Popstring_String, filter_arexx_string = BetterStringObject,
										StringFrame,
										MUIA_CycleChain,1,
										MUIA_String_Acknowledge, TRUE,
										End,
									End,

								Child, MakeLabel(_("Play Sound")),
								Child, filter_sound_check = MakeCheck(_("Play Sound"),FALSE),
								Child, filter_sound_string = AudioSelectGroupObject, MUIA_Disabled, TRUE, End,

								End,
							End,
						End,
					End,
				End,
			Child, HorizLineObject,
			Child, HGroup,
				Child, save_button = MakeButton(Q_("?filter:_Save")),
				Child, ok_button = MakeButton(_("_Use")),
				Child, cancel_button = MakeButton(_("_Cancel")),
				End,
			End,
		End;

	if (filter_wnd)
	{
		char *short_help_txt = _("If activated the filter will be used remotly on POP3 servers\n"
                             "which support the TOP command. Mails which matches the filter\n"
														 "are presented to the user and automatically marked as to be ignored.");

		set(filter_remote_label, MUIA_ShortHelp, short_help_txt);
		set(filter_remote_check, MUIA_ShortHelp, short_help_txt);

		DoMethod(App, OM_ADDMEMBER, (ULONG)filter_wnd);
		DoMethod(filter_wnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_cancel);
		DoMethod(ok_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_ok);
		DoMethod(save_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_ok);
		DoMethod(save_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)save_filter);
		DoMethod(cancel_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_cancel);

		DoMethod(filter_new_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_new);
		DoMethod(filter_remove_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_remove);
		DoMethod(filter_moveup_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_list, 3, MUIM_NList_Move, MUIV_NList_Move_Active, MUIV_NList_Move_Previous);
		DoMethod(filter_movedown_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_list, 3, MUIM_NList_Move, MUIV_NList_Move_Active, MUIV_NList_Move_Next);

		set(filter_name_string, MUIA_String_AttachedList, (ULONG)filter_list);
		DoMethod(filter_list, MUIM_Notify, MUIA_NList_Active, MUIV_EveryTime, (ULONG)filter_list, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_active);
		DoMethod(filter_name_string, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime, (ULONG)filter_list, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_name);

		DoMethod(filter_add_rule_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_add_rule_gui);
		DoMethod(filter_apply_now_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_apply);
		DoMethod(filter_move_check, MUIM_Notify, MUIA_Selected, MUIV_EveryTime, (ULONG)filter_move_popobject, 3, MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
		DoMethod(filter_sound_check, MUIM_Notify, MUIA_Selected, MUIV_EveryTime, (ULONG)filter_sound_string, 3, MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
		DoMethod(filter_arexx_check, MUIM_Notify, MUIA_Selected, MUIV_EveryTime, (ULONG)filter_arexx_popasl, 3, MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
		DoMethod(filter_folder_list, MUIM_Notify, MUIA_NList_DoubleClick, TRUE, (ULONG)filter_move_popobject, 2, MUIM_Popstring_Close, 1);

		filter_update_folder_list();
	}
}

//.........这里部分代码省略.........
                                                    MUIA_Numeric_Max, nhi->nhi_LogicalMax,
                                                    MUIA_Numeric_Value, nhi->nhi_OldValue,
                                                    End),
                                                End,
                                            Child, (IPTR)VSpace(0),
                                            End;
                                        nhgi->nhgi_ObjType = NHGIOT_SLIDER;
                                    }
                                } else {
                                    if((nhgi = nAllocGHCItem(nch, nhi, NULL, nhi->nhi_Usage)))
                                    {
                                        /* Vertical slider */
                                        obj = HGroup,
                                            Child, (IPTR)HSpace(0),
                                            Child, (IPTR)VGroup,
                                                Child, (IPTR)(nhgi->nhgi_GUIObj = SliderObject, SliderFrame,
                                                    MUIA_Slider_Horiz, FALSE,
                                                    MUIA_CycleChain, 1,
                                                    MUIA_Numeric_Min, nhi->nhi_LogicalMin,
                                                    MUIA_Numeric_Max, nhi->nhi_LogicalMax,
                                                    MUIA_Numeric_Value, nhi->nhi_OldValue,
                                                    End),
                                                Child, (IPTR)Label(nhgi->nhgi_Name),
                                                End,
                                            Child, (IPTR)HSpace(0),
                                            End;
                                        nhgi->nhgi_ObjType = NHGIOT_SLIDER;
                                    }
                                }
                            }
                        }
                        if(obj)
                        {
                            DoMethod(nch->nch_HCGroupObj, OM_ADDMEMBER, obj);
                            switch(nhgi->nhgi_ObjType)
                            {
                                case NHGIOT_SHOTBUTTON:
                                    DoMethod(nhgi->nhgi_GUIObj, MUIM_Notify, MUIA_Pressed, FALSE,
                                             nch->nch_HCActionObj, 2, MUIM_Action_UpdateHIDCtrl, nhgi);
                                    break;

                                case NHGIOT_TOGGLEBUTTON:
                                    DoMethod(nhgi->nhgi_GUIObj, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
                                             nch->nch_HCActionObj, 2, MUIM_Action_UpdateHIDCtrl, nhgi);
                                    break;

                                case NHGIOT_SLIDERIMM:
                                    DoMethod(nhgi->nhgi_GUIObj, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
                                             nch->nch_HCActionObj, 2, MUIM_Action_UpdateHIDCtrl, nhgi);
                                    break;

                                case NHGIOT_SLIDER:
                                    DoMethod(nhgi->nhgi_GUIObj, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
                                             nch->nch_HCActionObj, 2, MUIM_Action_UpdateHIDCtrl, nhgi);
                                    break;
                            }
                            numobj++;
                        }
                    } while(--count);
                }
            }
            nhr = (struct NepHidReport *) nhr->nhr_Node.ln_Succ;
        }
        if(!numobj)
        {
            DoMethod(nch->nch_HCGroupObj, OM_ADDMEMBER, Label("No output items in this interface!"));

/**
 * Refreshes the folder list. It should be called, whenever the folder list
 * has been changed.
 */
void filter_update_folder_list(void)
{
	DoMethod(filter_folder_list, MUIM_FolderTreelist_Refresh, NULL);
}

/**
 * Removes the currently selected filter.
 */
static void filter_remove(void)
{
	filter_last_selected = NULL;
	DoMethod(filter_list, MUIM_NList_Remove, MUIV_NList_Remove_Active);
}