/*!
* \brief Locking all or selected elements.
*
* Usage:\n
* UnlockElements(All)\n
* UE(All)\n
* If no argument is passed, no action is carried out.
*/
static int
unlock_elements (int argc, char **argv, Coord x, Coord y)
{
int all = 0;
if (strcasecmp (argv[0], "All") == 0)
all = 1;
else
{
Message ("ERROR: in UnlockElements argument should be All.\n");
return 1;
}
SET_FLAG (NAMEONPCBFLAG, PCB);
ELEMENT_LOOP(PCB->Data);
{
if (TEST_FLAG (LOCKFLAG, element))
{
/* element is locked */
if (all)
CLEAR_FLAG(LOCKFLAG, element);
}
}
END_LOOP;
gui->invalidate_all ();
IncrementUndoSerialNumber ();
return 0;
}
BOOLEAN
SpTerminateAdapterSynchronized(
IN PADAPTER_EXTENSION Adapter
)
{
//
// Disable the interrupt from coming in.
//
SET_FLAG(Adapter->InterruptData.InterruptFlags, PD_ADAPTER_REMOVED);
CLEAR_FLAG(Adapter->InterruptData.InterruptFlags, PD_RESET_HOLD);
ScsiPortCompleteRequest(Adapter->HwDeviceExtension,
0xff,
0xff,
0xff,
SRB_STATUS_NO_HBA);
//
// Run the completion DPC.
//
if(TEST_FLAG(Adapter->InterruptData.InterruptFlags,
PD_NOTIFICATION_REQUIRED)) {
SpRequestCompletionDpc(Adapter->DeviceObject);
}
return TRUE;
}
void delete_value(unit_box *boxes, INDEX index, INDEX i,INDEX j)
{
INDEX ri = 0, ci = 0, bi = 0;
UNIT val = 0;
bi = index;
ri = GET_ROW(bi)*COLUMN + i;
ci = GET_COLUMN(bi)*ROW + j;
val = boxes[index].value[i][j];
if(val > 0 && val <= TOTAL)
{
boxes[index].value[i][j] = 0;
CLEAR_FLAG(box[bi], val-1);
CLEAR_FLAG(row[ri], val-1);
CLEAR_FLAG(column[ci], val-1);
}
}
/*! \brief Receive one byte.
*
* This function receives one byte of data
* by accessing the Rx buffer.
*
* \note The SW_UART_RX_BUFFER_FULL flag
* must be one when this function
* is called.
*
* \return Data received.
*/
uint8_t SW_UART_Receive(void)
{
uint8_t data;
data = UART_Rx_buffer;
CLEAR_FLAG( SW_UART_status, SW_UART_RX_BUFFER_FULL );
return data;
}
/*
* Stream contains open file descriptors that could not be completed.
* If stream has only pending open file descriptors close file
* descriptors.
*/
static void
closeStream()
{
FileInfo_t *file;
int id;
id = Stream->first;
while (id > EOS) {
PthreadMutexLock(&Stream->mutex);
file = GetFile(id);
PthreadMutexLock(&file->mutex);
if (GET_FLAG(file->flags, FI_DCACHE_CLOSE)) {
if (close(file->dcache) == -1) {
WarnSyscallError(HERE,
"close", "");
}
CLEAR_FLAG(file->flags, FI_DCACHE);
NumOpenFiles--;
} else if (GET_FLAG(file->flags, FI_DCACHE)) {
SendErrorResponse(file);
}
id = file->next;
PthreadMutexUnlock(&Stream->mutex);
PthreadMutexUnlock(&file->mutex);
}
if (GET_FLAG(Stream->flags, SR_UNAVAIL)) {
rejectRequest(ENODEV, B_TRUE);
} else {
rejectRequest(0, B_TRUE);
}
}
/* ---------------------------------------------------------------------------
* moves a text object between layers; lowlevel routines
*/
static void *
MoveTextToLayerLowLevel (LayerType *Source, TextType *text,
LayerType *Destination)
{
RestoreToPolygon (PCB->Data, TEXT_TYPE, Source, text);
r_delete_entry (Source->text_tree, (BoxType *)text);
Source->Text = g_list_remove (Source->Text, text);
Source->TextN --;
Destination->Text = g_list_append (Destination->Text, text);
Destination->TextN ++;
if (GetLayerGroupNumberByNumber (solder_silk_layer) ==
GetLayerGroupNumberByPointer (Destination))
SET_FLAG (ONSOLDERFLAG, text);
else
CLEAR_FLAG (ONSOLDERFLAG, text);
/* re-calculate the bounding box (it could be mirrored now) */
SetTextBoundingBox (&PCB->Font, text);
if (!Destination->text_tree)
Destination->text_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (Destination->text_tree, (BoxType *)text, 0);
ClearFromPolygon (PCB->Data, TEXT_TYPE, Destination, text);
return text;
}
NTSTATUS
NTAPI
TGitNtQueryDirectoryFile(
HANDLE FileHandle,
HANDLE Event OPTIONAL,
PIO_APC_ROUTINE ApcRoutine OPTIONAL,
PVOID ApcContext OPTIONAL,
PIO_STATUS_BLOCK IoStatusBlock,
PVOID FileInformation,
ULONG Length,
FILE_INFORMATION_CLASS FileInformationClass,
BOOLEAN ReturnSingleEntry,
PUNICODE_STRING FileName OPTIONAL,
BOOLEAN RestartScan
)
{
NTSTATUS Status;
Status = StubNtQueryDirectoryFile(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock, FileInformation, Length, FileInformationClass, ReturnSingleEntry, FileName, RestartScan);
if (NT_SUCCESS(Status) && FileInformationClass == FileBothDirectoryInformation)
{
PFILE_BOTH_DIR_INFORMATION FileInfo;
FileInfo = (PFILE_BOTH_DIR_INFORMATION)FileInformation;
if (FileInfo != NULL)
{
CLEAR_FLAG(FileInfo->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT);
}
}
return Status;
}
/**
* Can the player be saved by an item?
* @param op Player to try to save.
* @retval 1 Player had his life saved by an item, first item saving life
* is removed.
* @retval 0 Player had no life-saving item. */
static int save_life(object *op)
{
object *tmp;
if (!QUERY_FLAG(op, FLAG_LIFESAVE))
{
return 0;
}
for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
{
if (QUERY_FLAG(tmp, FLAG_APPLIED) && QUERY_FLAG(tmp, FLAG_LIFESAVE))
{
play_sound_map(op->map, op->x, op->y, SOUND_OB_EVAPORATE, SOUND_NORMAL);
new_draw_info_format(NDI_UNIQUE, op, "Your %s vibrates violently, then evaporates.", query_name(tmp, NULL));
if (CONTR(op))
{
esrv_del_item(CONTR(op), tmp->count, tmp->env);
}
remove_ob(tmp);
CLEAR_FLAG(op, FLAG_LIFESAVE);
if (op->stats.hp < 0)
{
op->stats.hp = op->stats.maxhp;
}
if (op->stats.food < 0)
{
op->stats.food = 999;
}
/* Bring him home. */
enter_player_savebed(op);
return 1;
}
}
LOG(llevBug, "BUG: save_life(): LIFESAVE set without applied object.\n");
CLEAR_FLAG(op, FLAG_LIFESAVE);
/* Bring him home. */
enter_player_savebed(op);
return 0;
}
inline void catalog_object_header::validate() {
//S_LOCK(lock);
cs_pushp();
if (object != NULL) object->serialize();
cs_popp();
CLEAR_FLAG(flags, CAT_OBJECT_INVALID_FLAG);
//S_UNLOCK(lock);
};
//setup to run the code at the address, that the Interrupt Vector points to...
static void
setupInt(int intNum)
{
DEBUG_PRINTF_INTR("%s(%x): executing interrupt handler @%08x\n",
__func__, intNum, my_rdl(intNum * 4));
// push current R_FLG... will be popped by IRET
push_word((u16) M.x86.R_FLG);
CLEAR_FLAG(F_IF);
CLEAR_FLAG(F_TF);
// push current CS:IP to the stack, will be popped by IRET
push_word(M.x86.R_CS);
push_word(M.x86.R_IP);
// set CS:IP to the interrupt handler address... so the next executed instruction will
// be the interrupt handler
M.x86.R_CS = my_rdw(intNum * 4 + 2);
M.x86.R_IP = my_rdw(intNum * 4);
}
/* ---------------------------------------------------------------------------
* moves a element to buffer without allocating memory for pins/names
*/
static void *
MoveElementToBuffer (ElementType *element)
{
/*
* Delete the element from the source (remove it from trees,
* restore to polygons)
*/
r_delete_element (Source, element);
Source->Element = g_list_remove (Source->Element, element);
Source->ElementN --;
Dest->Element = g_list_append (Dest->Element, element);
Dest->ElementN ++;
PIN_LOOP (element);
{
RestoreToPolygon(Source, PIN_TYPE, element, pin);
CLEAR_FLAG (WARNFLAG | NOCOPY_FLAGS, pin);
}
END_LOOP;
PAD_LOOP (element);
{
RestoreToPolygon(Source, PAD_TYPE, element, pad);
CLEAR_FLAG (WARNFLAG | NOCOPY_FLAGS, pad);
}
END_LOOP;
SetElementBoundingBox (Dest, element, &PCB->Font);
/*
* Now clear the from the polygons in the destination
*/
PIN_LOOP (element);
{
ClearFromPolygon (Dest, PIN_TYPE, element, pin);
}
END_LOOP;
PAD_LOOP (element);
{
ClearFromPolygon (Dest, PAD_TYPE, element, pad);
}
END_LOOP;
return element;
}
/****************************************************************************
REMARKS:
Handles any pending asychronous interrupts.
****************************************************************************/
static void x86emu_intr_handle(void)
{
u8 intno;
if (M.x86.intr & INTR_SYNCH) {
intno = M.x86.intno;
if (_X86EMU_intrTab[intno]) {
(*_X86EMU_intrTab[intno])(intno);
} else {
push_word((u16)M.x86.R_FLG);
CLEAR_FLAG(F_IF);
CLEAR_FLAG(F_TF);
push_word(M.x86.R_CS);
M.x86.R_CS = mem_access_word(intno * 4 + 2);
push_word(M.x86.R_IP);
M.x86.R_IP = mem_access_word(intno * 4);
M.x86.intr = 0;
}
}
}
void NetConnection::shutdown()
{
if ( IS_SET(mFlags, eConnected) )
{
CLEAR_FLAG(mFlags, eConnected);
mSocket.close();
// remove the clients
mClients.clear();
}
}
void Set_RA_LDPC_8812(struct sta_info *psta, BOOLEAN bLDPC)
{
if (psta == NULL)
return;
#ifdef CONFIG_80211AC_VHT
if (psta->wireless_mode == WIRELESS_11_5AC) {
if (bLDPC && TEST_FLAG(psta->vhtpriv.ldpc_cap, LDPC_VHT_CAP_TX))
SET_FLAG(psta->vhtpriv.ldpc_cap, LDPC_VHT_ENABLE_TX);
else
CLEAR_FLAG(psta->vhtpriv.ldpc_cap, LDPC_VHT_ENABLE_TX);
} else
if (IsSupportedTxHT(psta->wireless_mode) || IsSupportedVHT(psta->wireless_mode)) {
if (bLDPC && TEST_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_CAP_TX))
SET_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_ENABLE_TX);
else
CLEAR_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_ENABLE_TX);
}
#endif
/* DBG_871X("MacId %d bLDPC %d\n", psta->mac_id, bLDPC); */
}
BOOLEAN
SpRemoveAdapterSynchronized(
PADAPTER_EXTENSION Adapter
)
{
//
// Disable the interrupt from coming in.
//
SET_FLAG(Adapter->InterruptData.InterruptFlags, PD_ADAPTER_REMOVED);
CLEAR_FLAG(Adapter->InterruptData.InterruptFlags, PD_RESET_HOLD);
return TRUE;
}
void update_params(unit_box *boxes, inv_unit_box *box, inv_unit_box *row, inv_unit_box *column)
{
INDEX i=0, j=0, bi=0;
for(i = 0 ; i < TOTAL ; i++)
for(j = 0 ; j < TOTAL ; j++)
{
CLEAR_FLAG(box[i], j);
CLEAR_FLAG(row[i], j);
CLEAR_FLAG(column[i], j);
}
for( bi= 0; bi < TOTAL; bi++)
for( i= 0; i < COLUMN; i++)
{
INDEX ri = GET_ROW(bi)*COLUMN + i;
for(j= 0; j < ROW; j++)
{
INDEX ci = GET_COLUMN(bi)*ROW + j;
UNIT val = boxes[bi].value[i][j]-1;
SET_FLAG(box[bi], val);
SET_FLAG(row[ri], val);
SET_FLAG(column[ci], val);
}
}
}
static IPTR mLampCleanup(struct IClass *cl,Object *obj,struct MUIP_Setup *msg)
{
struct lampData *data = INST_DATA(cl,obj);
if(isFlagSet(data->flags, FLG_LampSetup))
{
MUI_ReleasePen(muiRenderInfo(obj),data->enabled);
MUI_ReleasePen(muiRenderInfo(obj),data->disabled);
MUI_ReleasePen(muiRenderInfo(obj),data->detail);
CLEAR_FLAG(data->flags, FLG_LampSetup);
}
return DoSuperMethodA(cl,obj,(APTR)msg);
}
/**
* Handles showing of a trap.
* @param trap The trap.
* @param where Where.
* @return 1 if the trap was shown, 0 otherwise. */
int trap_show(object *trap, object *where)
{
object *env;
if (where == NULL)
{
return 0;
}
env = trap->env;
/* We must remove and reinsert it.. */
remove_ob(trap);
CLEAR_FLAG(trap, FLAG_SYS_OBJECT);
CLEAR_MULTI_FLAG(trap, FLAG_IS_INVISIBLE);
trap->layer = LAYER_EFFECT;
if (env && env->type != PLAYER && env->type != MONSTER && env->type != DOOR && !QUERY_FLAG(env, FLAG_NO_PASS))
{
SET_FLAG(env, FLAG_IS_TRAPPED);
/* Env object is on map */
if (!env->env)
{
update_object(env, UP_OBJ_FACE);
}
/* Somewhere else - if visible, update */
else
{
if (env->env->type == PLAYER || env->env->type == CONTAINER)
{
esrv_update_item(UPD_FLAGS, env->env, env);
}
}
insert_ob_in_ob(trap, env);
if (env->type == PLAYER || env->type == CONTAINER)
{
esrv_update_item(UPD_LOCATION, env, trap);
}
}
else
{
insert_ob_in_map(trap, where->map, NULL, 0);
}
return 1;
}
/* Turns the motor on and select drive */
static void start_motor(struct fdd *f)
{
if (FLAG_ON(f->flags, FDD_SPINDN))
/* Cancel the spindown timer */
;
CLEAR_FLAG(f->flags, FDD_SPINDN);
if (!IS_MOTOR_ON(f->fdc, f->number)) {
if (!FLAG_ON(f->flags, FDD_SPINUP))
/* TODO: Register motor spin callback */
;
f->fdc->dor |= (1 << (f->number + 4));
/* Select drive */
f->fdc->dor = (f->fdc->dor & 0xFC) | f->number;
fdc_out(f->fdc->base_port + FDC_DOR, f->fdc->dor);
}
}
static IPTR mLampSets(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct lampData *data = INST_DATA(cl,obj);
struct TagItem *tag;
if((tag = FindTagItem(MUIA_Lamp_Disabled,msg->ops_AttrList)))
{
if (tag->ti_Data)
SET_FLAG(data->flags, FLG_LampDisabled);
else
CLEAR_FLAG(data->flags, FLG_LampDisabled);
/* Of course, we don't redraw here */
}
return DoSuperMethodA(cl,obj,(Msg)msg);
}
/* ---------------------------------------------------------------------------
* moves a rat-line to paste buffer
*/
static void *
MoveRatToBuffer (RatType *rat)
{
r_delete_entry (Source->rat_tree, (BoxType *)rat);
Source->Rat = g_list_remove (Source->Rat, rat);
Source->RatN --;
Dest->Rat = g_list_append (Dest->Rat, rat);
Dest->RatN ++;
CLEAR_FLAG (NOCOPY_FLAGS, rat);
if (!Dest->rat_tree)
Dest->rat_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (Dest->rat_tree, (BoxType *)rat, 0);
return rat;
}
NTSTATUS
NTAPI
TGitNtQueryFullAttributesFile(
POBJECT_ATTRIBUTES ObjectAttributes,
PFILE_NETWORK_OPEN_INFORMATION FileInformation
)
{
NTSTATUS Status;
Status = StubNtQueryFullAttributesFile(ObjectAttributes, FileInformation);
if (NT_SUCCESS(Status))
{
CLEAR_FLAG(FileInformation->FileAttributes, FILE_ATTRIBUTE_REPARSE_POINT);
}
return Status;
}
/* ---------------------------------------------------------------------------
* moves a via to paste buffer without allocating memory for the name
*/
static void *
MoveViaToBuffer (PinType *via)
{
RestoreToPolygon (Source, VIA_TYPE, via, via);
r_delete_entry (Source->via_tree, (BoxType *) via);
Source->Via = g_list_remove (Source->Via, via);
Source->ViaN --;
Dest->Via = g_list_append (Dest->Via, via);
Dest->ViaN ++;
CLEAR_FLAG (WARNFLAG | NOCOPY_FLAGS, via);
if (!Dest->via_tree)
Dest->via_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (Dest->via_tree, (BoxType *)via, 0);
ClearFromPolygon (Dest, VIA_TYPE, via, via);
return via;
}
/**
* This is similar to handle_player(), but is only used by the new
* client/server stuff.
*
* This is sort of special, in that the new client/server actually uses
* the new speed values for commands.
* @param pl Player to handle.
* @retval -1 Player is invalid.
* @retval 0 No more actions to do.
* @retval 1 There are more actions we can do. */
int handle_newcs_player(player *pl)
{
object *op = pl->ob;
if (!op || !OBJECT_ACTIVE(op))
{
return -1;
}
handle_client(&pl->socket, pl);
if (!op || !OBJECT_ACTIVE(op) || pl->socket.status == Ns_Dead)
{
return -1;
}
/* Check speed. */
if (op->speed_left < 0.0f)
{
return 0;
}
/* If we are here, we're never paralyzed anymore. */
CLEAR_FLAG(op, FLAG_PARALYZED);
if (op->direction && (CONTR(op)->run_on || CONTR(op)->fire_on))
{
/* All move commands take 1 tick, at least for now. */
op->speed_left--;
move_player(op, op->direction);
if (op->speed_left > 0)
{
return 1;
}
else
{
return 0;
}
}
return 0;
}
/* ---------------------------------------------------------------------------
* moves a polygon to buffer. Doesn't allocate memory for the points
*/
static void *
MovePolygonToBuffer (LayerType *layer, PolygonType *polygon)
{
LayerType *lay = &Dest->Layer[GetLayerNumber (Source, layer)];
r_delete_entry (layer->polygon_tree, (BoxType *)polygon);
layer->Polygon = g_list_remove (layer->Polygon, polygon);
layer->PolygonN --;
lay->Polygon = g_list_append (lay->Polygon, polygon);
lay->PolygonN ++;
CLEAR_FLAG (NOCOPY_FLAGS, polygon);
if (!lay->polygon_tree)
lay->polygon_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (lay->polygon_tree, (BoxType *)polygon, 0);
return (polygon);
}
/* ---------------------------------------------------------------------------
* copies data from one polygon to another
* 'Dest' has to exist
*/
PolygonType *
CopyPolygonLowLevel (PolygonType *Dest, PolygonType *Src)
{
Cardinal hole = 0;
Cardinal n;
for (n = 0; n < Src->PointN; n++)
{
if (hole < Src->HoleIndexN && n == Src->HoleIndex[hole])
{
CreateNewHoleInPolygon (Dest);
hole++;
}
CreateNewPointInPolygon (Dest, Src->Points[n].X, Src->Points[n].Y);
}
SetPolygonBoundingBox (Dest);
Dest->Flags = Src->Flags;
CLEAR_FLAG (NOCOPY_FLAGS, Dest);
return (Dest);
}
/* ---------------------------------------------------------------------------
* copies a polygon to buffer
*/
static void *
AddPolygonToBuffer (LayerType *Layer, PolygonType *Polygon)
{
LayerType *layer = &Dest->Layer[GetLayerNumber (Source, Layer)];
PolygonType *polygon;
polygon = CreateNewPolygon (layer, Polygon->Flags);
CopyPolygonLowLevel (polygon, Polygon);
/* Update the polygon r-tree. Unlike similarly named functions for
* other objects, CreateNewPolygon does not do this as it creates a
* skeleton polygon object, which won't have correct bounds.
*/
if (!layer->polygon_tree)
layer->polygon_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (layer->polygon_tree, (BoxType *)polygon, 0);
CLEAR_FLAG (NOCOPY_FLAGS | ExtraFlag, polygon);
return (polygon);
}
/* ---------------------------------------------------------------------------
* moves a line to buffer
*/
static void *
MoveLineToBuffer (LayerType *layer, LineType *line)
{
LayerType *lay = &Dest->Layer[GetLayerNumber (Source, layer)];
RestoreToPolygon (Source, LINE_TYPE, layer, line);
r_delete_entry (layer->line_tree, (BoxType *)line);
layer->Line = g_list_remove (layer->Line, line);
layer->LineN --;
lay->Line = g_list_append (lay->Line, line);
lay->LineN ++;
CLEAR_FLAG (NOCOPY_FLAGS, line);
if (!lay->line_tree)
lay->line_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (lay->line_tree, (BoxType *)line, 0);
ClearFromPolygon (Dest, LINE_TYPE, lay, line);
return (line);
}
/* ---------------------------------------------------------------------------
* moves an arc to buffer
*/
static void *
MoveArcToBuffer (LayerType *layer, ArcType *arc)
{
LayerType *lay = &Dest->Layer[GetLayerNumber (Source, layer)];
RestoreToPolygon (Source, ARC_TYPE, layer, arc);
r_delete_entry (layer->arc_tree, (BoxType *)arc);
layer->Arc = g_list_remove (layer->Arc, arc);
layer->ArcN --;
lay->Arc = g_list_append (lay->Arc, arc);
lay->ArcN ++;
CLEAR_FLAG (NOCOPY_FLAGS, arc);
if (!lay->arc_tree)
lay->arc_tree = r_create_tree (NULL, 0, 0);
r_insert_entry (lay->arc_tree, (BoxType *)arc, 0);
ClearFromPolygon (Dest, ARC_TYPE, lay, arc);
return (arc);
}
static IPTR mUse(struct IClass *cl, Object *obj, UNUSED Msg msg)
{
struct data *data = INST_DATA(cl,obj);
struct URL_BrowserNode *bn = data->bn;
LONG i, visible, first;
CLEAR_FLAG(bn->ubn_Flags, UNF_NEW);
strlcpy(bn->ubn_Name, (STRPTR)xget(data->name,MUIA_String_Contents), sizeof(bn->ubn_Name));
strlcpy(bn->ubn_Path, (STRPTR)xget(data->path,MUIA_String_Contents), sizeof(bn->ubn_Path));
strlcpy(bn->ubn_Port, (STRPTR)xget(data->port,MUIA_String_Contents), sizeof(bn->ubn_Port));
strlcpy(bn->ubn_ShowCmd, (STRPTR)xget(data->show,MUIA_String_Contents), sizeof(bn->ubn_ShowCmd));
strlcpy(bn->ubn_ToFrontCmd, (STRPTR)xget(data->toFront,MUIA_String_Contents), sizeof(bn->ubn_ToFrontCmd));
strlcpy(bn->ubn_OpenURLCmd, (STRPTR)xget(data->openURL,MUIA_String_Contents), sizeof(bn->ubn_OpenURLCmd));
strlcpy(bn->ubn_OpenURLWCmd, (STRPTR)xget(data->openURLNW,MUIA_String_Contents), sizeof(bn->ubn_OpenURLWCmd));
visible = xget(data->browserList, MUIA_List_Visible);
if (visible!=-1)
{
first = xget(data->browserList, MUIA_List_First);
for (i = first; i < (first + visible); i++)
{
DoMethod(data->browserList,MUIM_List_GetEntry,i,(IPTR)&bn);
if (!bn) break;
if (bn==data->bn)
{
DoMethod(data->browserList,MUIM_List_Redraw,i);
break;
}
}
}
set(obj,MUIA_Window_CloseRequest,TRUE);
return TRUE;
}
