uint32 myStringClass_OM_Dispose( Class *cl, Object *obj, struct opSet *msg ) { struct myStringClassData *data; data = INST_DATA( cl, obj ); if ( data->Window ) { IDoMethod( data->WindowObject, WM_CLOSE ); data->Window = NULL; } if ( data->WindowObject ) { DisposeObject( data->WindowObject ); data->WindowObject = NULL; } return( IDoSuperMethodA( cl, obj, (APTR)msg )); }
static void freeitem(struct MenuItem *item, struct GadToolsBase_intern * GadToolsBase) { ULONG * p = (ULONG *)item - 1; DEBUG_FREEMENUS(bug("FreeItem: item %p\n", item)); DEBUG_FREEMENUS(bug("FreeItem: NextItem %p\n", item->NextItem)); DEBUG_FREEMENUS(bug("FreeItem: Left %ld Top %ld Width %ld Height %ld\n", item->LeftEdge,item->TopEdge,item->Width,item->Height)); DEBUG_FREEMENUS(bug("FreeItem: Flags 0x%lx ItemFill 0x%lx SelectFill 0x%lx\n", item->Flags,item->ItemFill,item->SelectFill)); DEBUG_FREEMENUS(bug("FreeItem: Command %lc SubItem 0x%lx NextSelect 0x%lx\n", item->Command,item->SubItem,item->NextSelect)); if (!(item->Flags & ITEMTEXT)) { struct Image *im = (struct Image *)item->ItemFill; DEBUG_FREEMENUS(bug("FreeItem: free image\n")); if (is_menubarlabelclass_image(im, GadToolsBase)) { DEBUG_FREEMENUS(bug("FreeItem: menubarimage %p\n",im)); DisposeObject(im); } } else { struct IntuiText *MyText=(struct IntuiText*) item->ItemFill; struct IntuiText *MyText2=(struct IntuiText*) item->SelectFill; if (MyText) { DEBUG_FREEMENUS(bug("FreeItem: FillName <%s>\n",MyText->IText)); } if (MyText2) { DEBUG_FREEMENUS(bug("FreeItem: SelectName <%s>\n",MyText2->IText)); } } DEBUG_FREEMENUS(bug("FreeItem: freeitem %p size %ld\n", p,*p)); FreeMem(p, *p); DEBUG_FREEMENUS(bug("FreeItem: done\n")); }
void ReadIncGRepeatedDef(unsigned typ, OBJECT encl) { OBJECT t, fname; t = LexGetToken(); if( type(t) != LBR ) { Error(5, 5, "left brace expected here in %s declaration", WARN, &fpos(t), KW_INCG_REPEATED); Dispose(t); return; } fname = Parse(&t, encl, FALSE, FALSE); fname = ReplaceWithTidy(fname, ACAT_TIDY); if( !is_word(type(fname)) ) { Error(5, 6, "name of %s file expected here", WARN, &fpos(fname), KW_INCG_REPEATED); DisposeObject(fname); return; } debug0(DFS, D, " calling PS_IncGRepeated from ReadPrependDef"); incg_type(fname) = (typ == INCG_REPEATED ? INCGRAPHIC : SINCGRAPHIC); PS_IncGRepeated(fname); } /* end ReadPrependDef */
void shutdownwnd_close(void) { if (shutdown_wnd) { CloseWindow(shutdown_wnd); shutdown_wnd = NULL; } if (obj) { DisposeObject(obj); obj = NULL; } if (scr) { ReleasePen(scr->ViewPort.ColorMap,pen); UnlockPubScreen(NULL,scr); scr = NULL; } }
IPTR Prop__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg) { struct Prop_DATA *data = INST_DATA(cl, obj); if (data->prop_object && !data->usewinborder) { RemoveGadget(_window(obj), (struct Gadget *) data->prop_object); DisposeObject(data->prop_object); } DisposeImageContainer(data->buffer); DisposeImageContainer(data->temp); if (data->mapbuffer != NULL) FreeBitMap(data->mapbuffer); if (data->maptemp != NULL) FreeBitMap(data->maptemp); if (data->tmprp != NULL) FreeRastPort(data->tmprp); data->buffer = NULL; data->temp = NULL; data->mapbuffer = NULL; data->maptemp = NULL; data->tmprp = NULL; return DoSuperMethodA(cl, obj, msg); }
static void DeleteSymBody(OBJECT s) { OBJECT t; debug1(DST, DDD, "DeleteSymBody( %s )", SymName(s)); switch( type(s) ) { case MACRO: while( sym_body(s) != nilobj ) { t = sym_body(s); sym_body(s) = Delete(sym_body(s), PARENT); Dispose(t); } break; case LPAR: case NPAR: case RPAR: case LOCAL: if( sym_body(s) != nilobj ) DisposeObject(sym_body(s)); break; default: assert1(FALSE, "DeleteSymBody:", Image(type(s))); break; } debug0(DST, DDD, "DeleteSymBody returning."); } /* end DeleteSymBody */
void RPG_DestructibleEntity::SetDestroyed() { m_isDestroyed = true; // remove the attackable component RPG_AttackableComponent* attackableComponent = static_cast<RPG_AttackableComponent*>(Components().GetComponentOfType(V_RUNTIME_CLASS(RPG_AttackableComponent))); if (attackableComponent) { RemoveComponent(attackableComponent); } vHavokRigidBody* rigidBodyComponent = static_cast<vHavokRigidBody*>(Components().GetComponentOfType(V_RUNTIME_CLASS(vHavokRigidBody))); if (rigidBodyComponent) { RemoveComponent(rigidBodyComponent); } // stop the ambient effect StopEffect(DEFX_Ambient); CreateEffect(DEFX_Destroy, GetPosition(), GetOrientation()); // remove collision if so instructed //if (m_removeCollisionAfterDestruction) { RemoveObstacle(); } if(!m_postDestructionMeshFilename.IsEmpty()) { // swap the mesh SetMesh(m_postDestructionMeshFilename); } else { DisposeObject(); } }
void ReadPrependDef(unsigned typ, OBJECT encl) { OBJECT t, fname; FILE_NUM fnum; t = LexGetToken(); if( type(t) != LBR ) { Error(5, 5, "left brace expected here in %s declaration", WARN, &fpos(t), KW_PREPEND); Dispose(t); return; } fname = Parse(&t, encl, FALSE, FALSE); fname = ReplaceWithTidy(fname, ACAT_TIDY); if( !is_word(type(fname)) ) { Error(5, 6, "name of %s file expected here", WARN, &fpos(fname),KW_PREPEND); DisposeObject(fname); return; } debug0(DFS, D, " calling DefineFile from ReadPrependDef"); fnum = FileNum(string(fname), STR_EMPTY); if( fnum == NO_FILE || FileType(fnum) != PREPEND_FILE ) DefineFile(string(fname), STR_EMPTY, &fpos(fname), PREPEND_FILE, typ == PREPEND ? INCLUDE_PATH : SYSINCLUDE_PATH); } /* end ReadPrependDef */
IPTR ModelClass__OM_DISPOSE(Class *cl, Object *o, Msg msg) { struct ModelData *data = (struct ModelData *)INST_DATA(cl, o); for(;;) { /* free all member objects */ Object *member, *objstate; ULONG method; objstate = (Object *)data->memberlist.mlh_Head; member = NextObject(&objstate); if (!member) break; method = OM_REMOVE; DoMethodA(member, (Msg)&method); DisposeObject(member); } return DoSuperMethodA(cl, o, msg); }
void main() { ULONG class,code; struct Gadget *gadget; struct IntuiMessage *message; struct DrawInfo *dri; BOOL running=TRUE; unless(Scr=LockPubScreen("Workbench")) LEAVE; unless(dri=GetScreenDrawInfo(Scr)) LEAVE; unless(SmartBitMapBase=OpenLibrary("images/smartbitmap.image",36L)) LEAVE; unless(ImClass=GetSmartBitMapClass()) LEAVE; GetRGB32(Scr->ViewPort.ColorMap,0,1,&pal[0].R); unless(Im=NewObject(ImClass,NULL, IA_Left,25, IA_Top,25, IA_Width,20, SMBM_Border,FALSE, SMBM_SelBorder,TRUE, SMBM_Screen,Scr, SMBM_BitMap,&TBCOLORWHEELBitMap, // SMBM_BitMap,&Size45UDBitMap, SMBM_Palette,pal, TAG_DONE)) LEAVE; unless(MainWnd=OpenWindowTags(NULL, WA_Left,0, WA_Top,0, WA_Width,600, WA_Height,200, WA_IDCMP,IDCMP_CLOSEWINDOW|IDCMP_GADGETUP, WA_Flags,WFLG_CLOSEGADGET|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_ACTIVATE|WFLG_SIZEGADGET, WA_CustomScreen,Scr, TAG_DONE)) LEAVE; DrawImageState(MainWnd->RPort,(struct Image *)Im,0,0,IDS_NORMAL,dri); while(running) { Wait(1L<<MainWnd->UserPort->mp_SigBit); while(message=GT_GetIMsg(MainWnd->UserPort)) { class=message->Class; code=message->Code; gadget=(struct Gadget *)message->IAddress; GT_ReplyIMsg(message); switch(class) { case IDCMP_CLOSEWINDOW: running=FALSE; break; } } } end: if(MainWnd) { CloseWindow(MainWnd); } if(Im) DisposeObject(Im); if(SmartBitMapBase) CloseLibrary(SmartBitMapBase); if(dri) FreeScreenDrawInfo(Scr,dri); if(Scr) UnlockPubScreen(NULL,Scr); }
void ami_arexx_cleanup(void) { if(arexx_obj) DisposeObject(arexx_obj); }
OBJECT ClosureExpand(OBJECT x, OBJECT env, BOOLEAN crs_wanted, OBJECT *crs, OBJECT *res_env) { OBJECT link, y, res, prnt_env, par, prnt; debug3(DCE, D, "[ ClosureExpand( %s, %s, %s, crs, res_env )", EchoObject(x), EchoObject(env), bool(crs_wanted)); assert( type(x) == CLOSURE, "ClosureExpand given non-CLOSURE!"); assert( predefined(actual(x)) == FALSE, "ClosureExpand given predefined!" ); /* add tag to x if needed but not provided; add cross-reference to crs */ if( has_tag(actual(x)) ) CrossAddTag(x); if( crs_wanted && has_tag(actual(x)) ) { OBJECT tmp = CopyObject(x, no_fpos); AttachEnv(env, tmp); y = CrossMake(actual(x), tmp, CROSS_TARG); New(tmp, CROSS_TARG); actual(tmp) = y; Link(tmp, y); if( *crs == nilobj ) New(*crs, CR_LIST); Link(*crs, tmp); } /* case x is a parameter */ res = *res_env = nilobj; if( is_par(type(actual(x))) ) { prnt = SearchEnv(env, enclosing(actual(x))); if( prnt != nilobj ) { prnt_env = GetEnv(prnt); for( link = Down(prnt); link != prnt; link = NextDown(link) ) { Child(par, link); if( type(par) == PAR && actual(par) == actual(x) ) { assert( Down(par) != par, "ExpandCLosure: Down(par)!"); Child(res, Down(par)); if( dirty(enclosing(actual(par))) || is_enclose(actual(par)) ) { debug2(DCE, DD, "copy %s %s", SymName(actual(par)), EchoObject(res)); res = CopyObject(res, no_fpos); } else { debug2(DCE, DD, "link %s %s", FullSymName(actual(par), AsciiToFull(".")), EchoObject(res)); DeleteLink(Down(par)); y = MakeWord(WORD, STR_NOCROSS, &fpos(res)); Link(par, y); } ReplaceNode(res, x); if( type(actual(x)) == RPAR && has_body(enclosing(actual(x))) ) { debug0(DCR, DDD, " calling SetEnv from ClosureExpand (a)"); *res_env = SetEnv(prnt, nilobj); DisposeObject(x); } else if( type(actual(x)) == NPAR && imports_encl(actual(x)) ) { debug0(DCR, DDD, " calling SetEnv from ClosureExpand (x)"); AttachEnv(env, x); *res_env = SetEnv(x, nilobj); } else { AttachEnv(env, x); debug0(DCR, DDD, " calling SetEnv from ClosureExpand (b)"); *res_env = SetEnv(x, prnt_env); } break; } } } else { /* fail only if there is no default value available */ if( sym_body(actual(x)) == nilobj ) { debug3(DCE, D, "failing ClosureExpand( %s, crs, %s, %s, res_env )", EchoObject(x), bool(crs_wanted), EchoObject(env)); Error(9, 2, "no value for parameter %s of symbol %s:", WARN, &fpos(x), SymName(actual(x)), SymName(enclosing(actual(x)))); Error(9, 1, "symbol with import list misused", FATAL, &fpos(x)); } } } /* case x is a user-defined symbol or default parameter */ if( res == nilobj ) { if( sym_body(actual(x)) == nilobj ) res = MakeWord(WORD, STR_NOCROSS, &fpos(x)); else res = CopyObject(sym_body(actual(x)), &fpos(x)); ReplaceNode(res, x); AttachEnv(env, x); debug0(DCR, DDD, " calling SetEnv from ClosureExpand (c)"); *res_env = SetEnv(x, nilobj); } assert( *res_env!=nilobj && type(*res_env)==ENV, "ClosureExpand: *res_env!"); debug0(DCE, D, "] ClosureExpand returning, res ="); ifdebug(DCE, D, DebugObject(res)); debug1(DCE, D, " environment = %s", EchoObject(*res_env)); return res; } /* end ClosureExpand */
void lister_close_window(Lister *lister,BOOL run_script) { short a; // If busy, hide progress window if (lister->progress_window) HideProgressWindow(lister->progress_window); // Fix current directory UnLock(CurrentDir(0)); // Free icon remapping backdrop_free_remap(lister->backdrop_info,lister->window); // Close window if (lister->window) { // Cancel edit lister_end_edit(lister,EDITF_CANCEL|EDITF_NOREFRESH); // Remove 'hot name' requester lister_rem_hotname(lister); // Run script? if (run_script) { char buf[16]; // Build handle string lsprintf(buf,"%ld",lister); // Run script RunScript(SCRIPT_CLOSE_LISTER,buf); } // Remove AppWindow RemoveAppWindow(lister->appwindow); lister->appwindow=0; // Remember window coordinates StoreWindowDims(lister->window,&lister->dimensions); if (lister->more_flags&LISTERF_TITLEBARRED) { lister->dimensions.wd_Normal.Width=lister->restore_dims.Width; lister->dimensions.wd_Normal.Height=lister->restore_dims.Height; } // If window was busy, abort timer if (lister->flags&LISTERF_BUSY) StopTimer(lister->busy_timer); // Clear menus display_free_menu(lister->window); // Free DrawInfo if (lister->drawinfo) { FreeScreenDrawInfo(lister->window->WScreen,lister->drawinfo); lister->drawinfo=0; } // Have we got a buffer? if (lister->cur_buffer) { // Store dimensions of window in buffer lister->cur_buffer->dimensions=*((struct IBox *)&lister->window->LeftEdge); lister->cur_buffer->dim_valid=1; } // Got Drag info? if (lister->drag_info) { // Free it FreeDragInfo(lister->drag_info); lister->drag_info=0; } // Close window CloseWindow(lister->window); lister->window=0; // Free edit hook FreeEditHook(lister->path_edit_hook); lister->path_edit_hook=0; } // Free render bitmap DisposeBitMap(lister->render_bitmap); lister->render_bitmap=0; // Free backdrop stuff backdrop_free_info(lister->backdrop_info); // Free gauge gadget if (lister->gauge_gadget) { DisposeObject((Object *)lister->gauge_gadget); lister->gauge_gadget=0; } // Free pens for (a=0;a<ENVCOL_MAX;a++) lister_init_colour(lister,a,TRUE); // Remember flags lister->old_flags=lister->flags; // Clear flags lister->flags&= LISTERF_LOCK_POS| LISTERF_ICONIFIED| LISTERF_BUSY| LISTERF_VIEW_ICONS| LISTERF_ICON_ACTION| LISTERF_SHOW_ALL; // Store source/destination status if (lister->old_flags&LISTERF_SOURCE) lister->flags|=LISTERF_STORED_SOURCE; else if (lister->old_flags&LISTERF_DEST) lister->flags|=LISTERF_STORED_DEST; }
/// /// HandleIDMCP PERROR HandleIDCMP( FRAME *frame, struct Objects *o, struct Values *v, struct PPTBase *PPTBase ) { ULONG sig, sigmask, sigport = 0L; struct Library *ColorWheelBase = o->ColorWheelBase; struct IntuitionBase *IntuitionBase = PPTBase->lb_Intuition; BOOL V39 = FALSE; if( PPTBase->lb_Gfx->LibNode.lib_Version >= 39 && ColorWheelBase ) V39 = TRUE; if(StartInput(frame, GINP_PICK_POINT, NULL) == PERR_OK) sigport = (1 << PPTBase->mport->mp_SigBit); GetAttr( WINDOW_SigMask, o->Win, &sigmask ); for(;;) { sig = Wait( sigport|sigmask|SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_F ); if( sig & SIGBREAKF_CTRL_C ) { SetErrorCode( frame, PERR_BREAK ); DisposeObject( o->Win ); StopInput(frame); return PERR_BREAK; } if( sig & SIGBREAKF_CTRL_F ) { WindowToFront( o->win ); ActivateWindow( o->win ); } if( sig & sigport ) { struct gPointMessage *gp; gp = (struct gPointMessage*)GetMsg(PPTBase->mport); /* * Ignore all other types of messages, except pickpoints. */ if( gp->msg.code == PPTMSG_PICK_POINT ) { D(bug("User picked point (%d,%d)\n",gp->x,gp->y)); if( frame->pix->colorspace == CS_RGB ) { RGBPixel *cp; cp = (RGBPixel *)GetPixelRow( frame, gp->y ); SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level, cp[gp->x].r, TAG_DONE ); SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level, cp[gp->x].g, TAG_DONE ); SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level, cp[gp->x].b, TAG_DONE ); } else { ARGBPixel *cp; cp = (ARGBPixel *)GetPixelRow( frame, gp->y ); SetGadgetAttrs( GAD(o->Trans), o->win, NULL, SLIDER_Level, cp[gp->x].a, TAG_DONE ); SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level, cp[gp->x].r, TAG_DONE ); SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level, cp[gp->x].g, TAG_DONE ); SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level, cp[gp->x].b, TAG_DONE ); } v->background = FALSE; } ReplyMsg( (struct Message *)gp ); } if( sig & sigmask ) { ULONG rc, tmp; struct ColorWheelRGB rgb; struct ColorWheelHSB hsb; while(( rc = HandleEvent( o->Win )) != WMHI_NOMORE ) { switch(rc) { case WMHI_CLOSEWINDOW: case GID_CANCEL: D(bug("User cancelled\n")); SetErrorCode( frame, PERR_CANCELED ); DisposeObject( o->Win ); StopInput(frame); return PERR_CANCELED; /* * Can't happen if running under <V39, but let's be * sure anyway */ case GID_GRADIENTSLIDER: if( V39 ) { GetAttr(GRAD_CurVal, o->RealGradient, &tmp); // D(bug("New value: %d\n",tmp)); GetAttr( WHEEL_HSB, o->Wheel, (ULONG *)&hsb ); hsb.cw_Brightness = (0xFFFF - tmp) * 0x00010001; ConvertHSBToRGB( &hsb, &rgb ); SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level, rgb.cw_Red>>24, TAG_DONE ); SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level, rgb.cw_Green>>24, TAG_DONE ); SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level, rgb.cw_Blue>>24, TAG_DONE ); v->background = FALSE; } break; /* * Ditto */ case GID_WHEEL: if( V39 ) { GetAttr( WHEEL_RGB, o->Wheel, (ULONG *) &rgb ); SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level, rgb.cw_Red>>24, TAG_DONE ); SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level, rgb.cw_Green>>24, TAG_DONE ); SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level, rgb.cw_Blue>>24, TAG_DONE ); v->background = FALSE; } break; case GID_RED: if( V39 ) { GetAttr( SLIDER_Level, o->Red, (ULONG *)&tmp ); GetAttr( WHEEL_RGB, o->Wheel, (ULONG *) &rgb ); rgb.cw_Red = tmp * 0x01010101; SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE ); v->background = FALSE; } break; case GID_GREEN: if( V39 ) { GetAttr( SLIDER_Level, o->Green, (ULONG *)&tmp ); GetAttr( WHEEL_RGB, o->Wheel, (ULONG *) &rgb ); rgb.cw_Green = tmp * 0x01010101; SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE ); v->background = FALSE; } break; case GID_BLUE: if( V39 ) { GetAttr( SLIDER_Level, o->Blue, (ULONG *)&tmp ); GetAttr( WHEEL_RGB, o->Wheel, (ULONG *) &rgb ); rgb.cw_Blue = tmp * 0x01010101; SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE ); v->background = FALSE; } break; case GID_BACKGROUND: GetBackGround( frame, v, PPTBase ); if( V39 ) { rgb.cw_Red = v->r * 0x01010101; rgb.cw_Green = v->g * 0x01010101; rgb.cw_Blue = v->b * 0x01010101; SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE ); DoMethod( o->Win, WM_REPORT_ID, GID_WHEEL, 0L ); // A bug in OS? } else { SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level,v->r, TAG_DONE ); SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level,v->g, TAG_DONE ); SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level,v->b, TAG_DONE ); } break; case GID_BLACK: rgb.cw_Red = rgb.cw_Green = rgb.cw_Blue = 0L; if( V39 ) { SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE ); DoMethod( o->Win, WM_REPORT_ID, GID_WHEEL, 0L ); // A bug in OS? } else { SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level,rgb.cw_Red>>24, TAG_DONE ); SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level,rgb.cw_Green>>24, TAG_DONE ); SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level,rgb.cw_Blue>>24, TAG_DONE ); } v->background = FALSE; break; case GID_WHITE: rgb.cw_Red = rgb.cw_Green = rgb.cw_Blue = 0xFFFFFFFF; if (V39 ) { SetGadgetAttrs( GAD(o->Wheel), o->win, NULL, WHEEL_RGB, &rgb, TAG_DONE ); DoMethod( o->Win, WM_REPORT_ID, GID_WHEEL, 0L ); // A bug in OS? } else { SetGadgetAttrs( GAD(o->Red), o->win, NULL, SLIDER_Level,rgb.cw_Red>>24, TAG_DONE ); SetGadgetAttrs( GAD(o->Green), o->win, NULL, SLIDER_Level,rgb.cw_Green>>24, TAG_DONE ); SetGadgetAttrs( GAD(o->Blue), o->win, NULL, SLIDER_Level,rgb.cw_Blue>>24, TAG_DONE ); } v->background = FALSE; break; case GID_OK: D(bug("User hit OK\n")); DoGadgets( frame, o, v, PPTBase ); GetAttr( WINDOW_Bounds, o->Win, (ULONG *)&v->window ); DisposeObject( o->Win ); StopInput(frame); return PERR_OK; } } } /* if(sig&sigmask) */ }
// Listview dispatcher ULONG LIBFUNC listview_dispatch( REG(a0, Class *cl), REG(a2, Object *obj), REG(a1, Msg msg)) { ListViewData *data=0; struct Gadget *gadget=0; ULONG retval=0; // Get gadget and data pointers if (obj) { gadget=(struct Gadget *)obj; data=INST_DATA(cl,obj); } // Look at method switch (msg->MethodID) { // Create a new instance case OM_NEW: // Create superclass instance if ((retval=DoSuperMethodA(cl,obj,msg))) { struct TagItem *tags,*tag; short a; struct Image *image; struct TextAttr *attr; // Get pointer to our gadget and instance data gadget=(struct Gadget *)retval; data=INST_DATA(cl,(APTR)retval); // Initialise data data->dims=*(struct IBox *)&gadget->LeftEdge; NewList(&data->boopsi_list); data->sel=-1; data->last_selection=-1; // Initialise mapping tags data->scroll_map[0].ti_Tag=PGA_Top; data->scroll_map[0].ti_Data=DLV_Top; data->scroll_map[1].ti_Tag=TAG_END; data->arrow_up_map[0].ti_Tag=GA_ID; data->arrow_up_map[0].ti_Data=DLV_ScrollUp; data->arrow_up_map[1].ti_Tag=TAG_END; data->arrow_down_map[0].ti_Tag=GA_ID; data->arrow_down_map[0].ti_Data=DLV_ScrollDown; data->arrow_down_map[1].ti_Tag=TAG_END; // Get taglist tags=((struct opSet *)msg)->ops_AttrList; // Get width of scroller data->scroller_width=GetTagData(DLV_ScrollWidth,16,tags); // Flags if (FindTagItem(DLV_ShowSelected,tags)) data->flags|=LVF_SHOW_SELECTED; if (GetTagData(DLV_ThinBorder,0,tags)) data->flags|=LVF_THIN_BORDER; if (GetTagData(DLV_MultiSelect,0,tags)) data->flags|=LVF_MULTI_SELECT; else if (GetTagData(DLV_Check,0,tags)) data->flags|=LVF_SELECTED_CHECK; else if ((a=GetTagData(DLV_ShowChecks,0,tags))) { data->flags|=LVF_SHOW_CHECKS; if (a==2) data->flags|=LVF_NO_HIGHLIGHT; } if (GetTagData(DLV_Highlight,0,tags)) data->flags|=LVF_SELECTED_HIGH; if (GetTagData(DLV_ReadOnly,0,tags)) data->flags|=LVF_READ_ONLY; if (GetTagData(DLV_NoScroller,0,tags)) { data->flags|=LVF_NO_SCROLLER; data->scroller_width=0; } else if (GetTagData(DLV_ScrollLeft,0,tags)) data->flags|=LVF_SCROLLER_LEFT; if (GetTagData(DLV_TopJustify,0,tags)) data->flags|=LVF_TOP_JUSTIFY; if (GetTagData(DLV_RightJustify,0,tags)) data->flags|=LVF_RIGHT_JUSTIFY; if ((a=GetTagData(DLV_DragNotify,0,tags))) { data->flags|=LVF_DRAG_NOTIFY; if (a==2) data->flags|=LVF_NO_VERT_SCROLL; } data->layout_flags=GetTagData(DLV_Flags,PLACETEXT_ABOVE,tags); if (GetTagData(DLV_ShowFilenames,0,tags)) data->flags|=LVF_SHOW_FILENAMES; if (GetTagData(DLV_ShowSeparators,0,tags)) data->flags|=LVF_SHOW_SEPARATORS; // Get title if ((tag=FindTagItem(GA_Text,tags))) { char *ptr; short pos=0; // Get pointer to title if ((ptr=(char *)tag->ti_Data)) { data->title_uscore=-1; // Copy title string, look for underscore while (*ptr && pos<78) { // Underscore? if (*ptr=='_') { // Remember position, skip over it data->title_uscore=pos; } // Otherwise, store else data->title[pos++]=*ptr; ++ptr; } data->title[pos]=0; } } // Get font to use if ((attr=(struct TextAttr *)GetTagData(GTCustom_TextAttr,0,tags))) { if ((data->list_font=OpenFont(attr))) data->flags|=LVF_GOT_FONT; } if (!data->list_font) data->list_font=((struct GfxBase *)GfxBase)->DefaultFont; // Arrow height data->arrow_height=data->list_font->tf_YSize-2; if (data->arrow_height<10) data->arrow_height=10; // Fix dimensions listview_get_dims(cl,data); data->text_height=data->list_font->tf_YSize; // Need check mark? if (data->flags&(LVF_MULTI_SELECT|LVF_SHOW_CHECKS) || (data->flags&(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))==(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK)) { // Create check image if ((data->check=(struct Image *)NewObject( 0,"dopusiclass", DIA_Type,IM_CHECK, IA_Width,13, IA_Height,data->text_height-1, TAG_END))) { // Add to boopsi list DoMethod((Object *)data->check,OM_ADDTAIL,&data->boopsi_list); } data->text_offset=23; } else data->text_offset=2; // Scroller needed? if (!(data->flags&LVF_NO_SCROLLER)) { // Create scroller if ((data->scroller=(struct Gadget *)NewObject( 0,"propgclass", GA_Previous,gadget, GA_ID,LVGID_SCROLLER, GA_Left,(data->flags&LVF_SCROLLER_LEFT)?data->dims.Left+4:data->dims.Left+data->dims.Width-data->scroller_width+4, GA_Top,data->dims.Top+2, GA_Width,data->scroller_width-8, GA_Height,data->dims.Height-4-(data->arrow_height<<1), GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE, PGA_Freedom,FREEVERT, PGA_NewLook, TRUE, PGA_Borderless,TRUE, PGA_Visible,1, PGA_Total,1, ICA_TARGET,gadget, ICA_MAP,data->scroll_map, TAG_END))) { // Add to boopsi list DoMethod((Object *)data->scroller,OM_ADDTAIL,&data->boopsi_list); } // Create up arrow image if ((image=(struct Image *)NewObject( 0,"dopusiclass", IA_Width,data->scroller_dims.Width, IA_Height,data->arrow_height, DIA_Type,IM_ARROW_UP, DIA_ThinBorders,(data->flags&LVF_THIN_BORDER)?TRUE:FALSE, TAG_END))) { // Add to boopsi list DoMethod((Object *)image,OM_ADDTAIL,&data->boopsi_list); } // Create up arrow button if ((data->arrows[0]=(struct Gadget *)NewObject( 0,"buttongclass", GA_ID,LVGID_ARROW, GA_Previous,data->scroller, GA_Left,data->scroller_dims.Left, GA_Top,data->scroller_dims.Top+data->scroller_dims.Height, GA_Width,data->scroller_dims.Width, GA_Height,data->arrow_height, GA_Image,image, GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE, ICA_TARGET,gadget, ICA_MAP,data->arrow_up_map, TAG_END))) { // Add to boopsi list DoMethod((Object *)data->arrows[0],OM_ADDTAIL,&data->boopsi_list); } // Create down arrow image if ((image=(struct Image *)NewObject( 0,"dopusiclass", IA_Width,data->scroller_dims.Width, IA_Height,data->arrow_height, DIA_Type,IM_ARROW_DOWN, DIA_ThinBorders,(data->flags&LVF_THIN_BORDER)?TRUE:FALSE, TAG_END))) { // Add to boopsi list DoMethod((Object *)image,OM_ADDTAIL,&data->boopsi_list); } // Create down arrow button if ((data->arrows[1]=(struct Gadget *)NewObject( 0,"buttongclass", GA_ID,LVGID_ARROW, GA_Previous,data->arrows[0], GA_Left,data->scroller_dims.Left, GA_Top,data->scroller_dims.Top+data->scroller_dims.Height+data->arrow_height, GA_Width,data->scroller_dims.Width, GA_Height,data->arrow_height, GA_Image,image, GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE, ICA_TARGET,gadget, ICA_MAP,data->arrow_down_map, TAG_END))) { // Add to boopsi list DoMethod((Object *)data->arrows[1],OM_ADDTAIL,&data->boopsi_list); } } } else break; // Fall through to OM_SET // Update/Set case OM_UPDATE: case OM_SET: { struct TagItem *tag,*tags; unsigned short old; struct Node *node; short item; short redraw=0; // Get taglist tags=((struct opSet *)msg)->ops_AttrList; // Make visible? if ((tag=FindTagItem(DLV_MakeVisible,tags))) { short scroll; // Remember old top old=data->top; // Get scroll amount scroll=tag->ti_Data-old; // Need to scroll? if (scroll<0 || scroll>=data->lines) { // Get scroll amount if (scroll>=data->lines) scroll-=data->lines-1; // Get new top data->top+=scroll; // Bounds check if (data->top>data->count-data->lines) data->top=data->count-data->lines; if (data->top<0) data->top=0; // Redraw? if (old!=data->top) { data->last_sel=-1; redraw=2; } } } // New top? else if ((tag=FindTagItem(DLV_Top,tags))) { // Remember old top old=data->top; // Get new top data->top=tag->ti_Data; // Bounds check if (data->top>data->count-data->lines) data->top=data->count-data->lines; if (data->top<0) data->top=0; // Redraw? if (old!=data->top) { data->last_sel=-1; redraw=2; } } // Scroll up else if ((tag=FindTagItem(DLV_ScrollUp,tags))) { // Is this the gadgetup? if (msg->MethodID==OM_UPDATE && !(((struct opUpdate *)msg)->opu_Flags&OPUF_INTERIM)) { // Clear scroll count data->scroll_count=0; } // Or is this the second/third scroll (first/second intuitick)? else if (msg->MethodID==OM_UPDATE && (data->scroll_count==1 || data->scroll_count==2)) { // Throw this away ++data->scroll_count; } // Otherwise, check it's valid else if (tag->ti_Data!=(ULONG)-LVGID_ARROW) { // Bounds check if (data->top>0) { --data->top; data->last_sel=-1; redraw=2; } // Increment scroll count if necessary if (msg->MethodID==OM_UPDATE) ++data->scroll_count; } } // Scroll down else if ((tag=FindTagItem(DLV_ScrollDown,tags))) { // Is this the gadgetup? if (msg->MethodID==OM_UPDATE && !(((struct opUpdate *)msg)->opu_Flags&OPUF_INTERIM)) { // Clear scroll count data->scroll_count=0; } // Or is this the second/third scroll (first/second intuitick)? else if (msg->MethodID==OM_UPDATE && (data->scroll_count==1 || data->scroll_count==2)) { // Throw this away ++data->scroll_count; } // Otherwise, check it's valid else if (tag->ti_Data!=(ULONG)-LVGID_ARROW) { // Bounds check if (data->top<data->count-data->lines) { ++data->top; data->last_sel=-1; redraw=2; } // Increment scroll count if necessary if (msg->MethodID==OM_UPDATE) ++data->scroll_count; } } // New labels if ((tag=FindTagItem(DLV_Labels,tags))) { // clear top item data->top_item=0; // Store new label pointer data->labels=(struct List *)tag->ti_Data; // Detached list? if (data->labels==(struct List *)~0) data->flags|=LVF_DETACHED; // No list else if (data->labels==0) { // Clear detach flag data->count=0; data->flags&=~LVF_DETACHED; redraw=1; } // Valid list else { // Count items for (data->count=0,node=data->labels->lh_Head; node->ln_Succ; data->count++,node=node->ln_Succ); // Bounds check top if (data->top+data->lines>data->count) data->top=data->count-data->lines; if (data->top<0) data->top=0; // Check selection for out-of-bounds if (data->sel>data->count-1) data->sel=-1; // Clear detach flag data->flags&=~LVF_DETACHED; redraw=1; } } // Selected if ((tag=FindTagItem(DLV_Selected,tags)) || (tag=FindTagItem(DLV_SelectPrevious,tags)) || (tag=FindTagItem(DLV_SelectNext,tags)) || (tag=FindTagItem(DLV_PageUp,tags)) || (tag=FindTagItem(DLV_PageDown,tags)) || (tag=FindTagItem(DLV_Home,tags)) || (tag=FindTagItem(DLV_End,tags))) { // Store old old=data->sel; // Get new selected if (tag->ti_Tag==DLV_Selected) { data->sel=tag->ti_Data; } else if (tag->ti_Tag==DLV_SelectPrevious) { if (data->sel>0) --data->sel; } else if (tag->ti_Tag==DLV_SelectNext) { ++data->sel; } else if (tag->ti_Tag==DLV_PageUp) { if (data->sel==data->top) data->sel-=data->lines-1; else data->sel=data->top; if (data->sel<0) data->sel=0; } else if (tag->ti_Tag==DLV_PageDown) { if (data->sel==data->top+data->lines-1) data->sel+=data->lines-1; else data->sel=data->top+data->lines-1; } else if (tag->ti_Tag==DLV_Home) { data->sel=0; } else if (tag->ti_Tag==DLV_End) { data->sel=data->count-1; } // Bounds check if (data->sel>data->count-1) data->sel=data->count-1; if (data->sel<0) data->sel=-1; // Changed? if (data->sel!=old && !(gadget->Flags&GFLG_DISABLED)) { // Save selection if (!redraw) { data->last_sel=data->last_selection; redraw=2; } data->last_selection=data->sel; // Send notify DoMethod(obj,OM_NOTIFY,0,((struct opSet *)msg)->ops_GInfo,0); } } // Disabled (set only) if (msg->MethodID==OM_SET && (tag=FindTagItem(GA_Disabled,tags))) { // Different to current state? if ((tag->ti_Data && !(gadget->Flags&GFLG_DISABLED)) || (!tag->ti_Data && gadget->Flags&GFLG_DISABLED)) { struct TagItem distags[2]; short a; // Fill out disable tags distags[0].ti_Tag=GA_Disabled; distags[0].ti_Data=tag->ti_Data; distags[1].ti_Tag=TAG_DONE; // Set state of slider if (data->scroller) { DoMethod( (Object *)data->scroller, OM_SET, distags, ((struct opSet *)msg)->ops_GInfo); // And arrows for (a=0;a<2;a++) DoMethod( (Object *)data->arrows[a], OM_SET, distags, ((struct opSet *)msg)->ops_GInfo); // Set flag to say disable state changed if (!tag->ti_Data) data->flags|=LVF_DISABLE_CHANGE; } // Change disable state and redraw gadget->Flags^=GFLG_DISABLED; redraw=1; } } // Get top item if (!data->labels) data->top_item=0; else if (!(data->flags&LVF_DETACHED) && data->labels) { for (node=data->labels->lh_Head,item=0; node->ln_Succ && item<data->top; node=node->ln_Succ,item++); data->top_item=node; } // Do we need to redraw the list? if (msg->MethodID==OM_SET || msg->MethodID==OM_UPDATE) { if (redraw && !(data->flags&LVF_DETACHED)) { struct RastPort *rp; // Get rastport if ((rp=ObtainGIRPort(((struct opSet *)msg)->ops_GInfo))) { // Send redraw DoMethod( obj, GM_RENDER, ((struct opSet *)msg)->ops_GInfo, rp, (redraw==2)?GREDRAW_UPDATE:GREDRAW_REDRAW); ReleaseGIRPort(rp); } } } } break; // Get an attribute case OM_GET: { struct opGet *get; // Get get message get=(struct opGet *)msg; // Default to ok retval=1; // Look at attribute switch (get->opg_AttrID) { // Selected case DLV_Selected: *get->opg_Storage=(ULONG)data->last_selection; break; // Top case DLV_Top: *get->opg_Storage=(ULONG)data->top; break; // Lines case DLV_Lines: *get->opg_Storage=(ULONG)data->lines; break; // Labels case DLV_Labels: *get->opg_Storage=(ULONG)data->labels; break; // Get line from coordinates case DLV_GetLine: { unsigned short x,y; struct gpInput fake; // Get coordinates x=((*get->opg_Storage)>>16)&0xffff; y=(*get->opg_Storage)&0xffff; // Fake gpInput fake.gpi_Mouse.X=x-gadget->LeftEdge; fake.gpi_Mouse.Y=y-gadget->TopEdge; // Get selection *get->opg_Storage=(ULONG)listview_get_sel(cl,gadget,data,&fake,0); } break; // Draw a line from the listview case DLV_DrawLine: { ListViewDraw *draw=(ListViewDraw *)*get->opg_Storage; // Draw line listview_draw_item( cl, gadget, draw->rp, draw->drawinfo, data, draw->node, draw->line, &draw->box); } break; // Other default: retval=DoSuperMethodA(cl,obj,msg); break; } } break; // Kill an instance case OM_DISPOSE: { APTR object_ptr; Object *object; // Free BOOPSI objects object_ptr=data->boopsi_list.lh_Head; while ((object=NextObject((APTR)&object_ptr))) DisposeObject(object); // Free font if (data->flags&LVF_GOT_FONT) CloseFont(data->list_font); retval=DoSuperMethodA(cl,obj,msg); } break; // Render gadget case GM_RENDER: // Cache DrawInfo data->draw_info=((struct gpRender *)msg)->gpr_GInfo->gi_DrInfo; // If a full redraw, clear double-click time if (((struct gpRender *)msg)->gpr_Redraw==GREDRAW_REDRAW) data->seconds=0; // Show gadget listview_render(cl,gadget,data,(struct gpRender *)msg); break; // Hit test case GM_HITTEST: { struct gpHitTest *test; // Get test pointer test=(struct gpHitTest *)msg; // See if we're hit if (test->gpht_Mouse.X>=data->text_dims.Left-gadget->LeftEdge && test->gpht_Mouse.Y>=data->text_dims.Top-gadget->TopEdge && test->gpht_Mouse.X<data->text_dims.Left+data->text_dims.Width-gadget->LeftEdge && test->gpht_Mouse.Y<data->text_dims.Top+data->text_dims.Height-gadget->TopEdge) { retval=GMR_GADGETHIT; } } break; // Notify case OM_NOTIFY: // Drag notify? if (data->flags&LVF_DRAG_FLAG) { // Fill out tags data->notify_tags[0].ti_Tag=DLV_DragNotify; data->notify_tags[0].ti_Data=data->drag_sel; data->notify_tags[1].ti_Tag=GA_ID; data->notify_tags[1].ti_Data=gadget->GadgetID; data->notify_tags[2].ti_Tag=GA_Left; data->notify_tags[2].ti_Data=data->text_dims.Left; data->notify_tags[3].ti_Tag=GA_Top; data->notify_tags[3].ti_Data=data->text_dims.Top+ UMult32(data->drag_sel-data->top,data->text_height); data->notify_tags[4].ti_Tag=GA_Width; data->notify_tags[4].ti_Data=data->text_dims.Width; data->notify_tags[5].ti_Tag=GA_Height; data->notify_tags[5].ti_Data=data->text_height; data->notify_tags[6].ti_Tag=GA_RelRight; data->notify_tags[6].ti_Data=data->drag_x_position; data->notify_tags[7].ti_Tag=GA_RelBottom; data->notify_tags[7].ti_Data=data->drag_y_position; data->notify_tags[8].ti_Tag=DLV_Top; data->notify_tags[8].ti_Data=data->top; data->notify_tags[9].ti_Tag=DLV_Object; data->notify_tags[9].ti_Data=(ULONG)gadget; data->notify_tags[10].ti_Tag=TAG_END; // Clear flag data->flags&=~LVF_DRAG_FLAG; } // Otherwise normal notify else { ULONG seconds,micros; // Fill out tags data->notify_tags[0].ti_Tag=DLV_Selected; data->notify_tags[0].ti_Data=data->last_selection; data->notify_tags[1].ti_Tag=GA_ID; data->notify_tags[1].ti_Data=gadget->GadgetID; data->notify_tags[2].ti_Tag=TAG_END; // Get current time CurrentTime(&seconds,µs); // Double-click? if (data->click_sel==data->last_selection && DoubleClick(data->seconds,data->micros,seconds,micros)) { // Set double-click flag data->notify_tags[2].ti_Tag=DLV_DoubleClick; data->notify_tags[2].ti_Data=TRUE; data->notify_tags[3].ti_Tag=TAG_END; // Clear double-click data->seconds=0; } // Otherwise else { // Remember double-click data->seconds=seconds; data->micros=micros; data->click_sel=data->last_selection; } } // Send message DoSuperMethod(cl,obj,OM_NOTIFY,data->notify_tags,((struct opUpdate *)msg)->opu_GInfo,0); break; // Go (in)active/Handle input case GM_GOACTIVE: case GM_GOINACTIVE: case GM_HANDLEINPUT: { struct gpInput *input; short redraw=0; // Get input pointer input=(struct gpInput *)msg; // Go active? if (input->MethodID==GM_GOACTIVE) { // Default is not to activate retval=GMR_NOREUSE; // Ok to go active? if (!(gadget->Flags&GFLG_DISABLED) && input->gpi_IEvent) { // Left button down and valid list? if (input->gpi_IEvent->ie_Code==SELECTDOWN && data->labels && !(data->flags&(LVF_READ_ONLY|LVF_DETACHED))) { short sel; // Get selection if ((sel=listview_get_sel(cl,gadget,data,input,0))>-1) { // Ok to activate retval=GMR_MEACTIVE; // Store current top data->last_top=data->top; // Remember x and y click-offset data->drag_x_position=input->gpi_Mouse.X- (data->text_dims.Left-data->dims.Left); data->drag_y_position=input->gpi_Mouse.Y- (data->text_dims.Top-data->dims.Top)- UMult32(sel-data->top,data->text_height); // Change? if (data->sel!=sel || !(data->flags&LVF_SHOW_SELECTED) || (data->flags&LVF_SELECTED_CHECK)) { // New selection data->last_sel=data->last_selection; data->sel=sel; redraw=1; } // Set selected flag gadget->Flags|=GFLG_SELECTED; } } } } // Go inactive? else if (msg->MethodID==GM_GOINACTIVE) { // Clear selected flag gadget->Flags&=~GFLG_SELECTED; // If we're showing selection with checks, we need to redraw last selection if ((data->flags&(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))==(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK)) data->last_sel=data->last_selection; redraw=1; // Save this selection data->last_selection=data->sel; // Send notify DoMethod(obj,OM_NOTIFY,0,((struct gpInput *)msg)->gpi_GInfo,0); // Clear cancel flag data->flags&=~LVF_CANCEL; } // Handle input else { // Default return value retval=GMR_MEACTIVE; // Is it a mouse event? if (input->gpi_IEvent->ie_Class==IECLASS_RAWMOUSE) { // Look at mouse code switch (input->gpi_IEvent->ie_Code) { // Left button up case SELECTUP: { // Set return code *input->gpi_Termination=data->sel; // Gadget processing finished retval=GMR_NOREUSE|GMR_VERIFY; data->flags|=LVF_CANCEL; // Multi-selection? if (data->flags&LVF_MULTI_SELECT) { struct Node *node; short count; // Get this node for (node=data->labels->lh_Head,count=0; node->ln_Succ && count<data->sel; node=node->ln_Succ,count++); // Did we get it? if (node && node->ln_Succ) { // Save old selection data->last_sel=data->sel; // Toggle selection node->lve_Flags^=LVEF_SELECTED; redraw=1; } } } break; // No button; mouse moved case IECODE_NOBUTTON: { short sel; // Is mouse outside of lister? if (input->gpi_Mouse.X<0 || input->gpi_Mouse.X>=data->list_dims.Width) { // Drag notify? if (data->flags&LVF_DRAG_NOTIFY) { // Valid selection? if (data->sel>-1) { // Notify drag data->flags|=LVF_DRAG_FLAG; data->drag_sel=data->sel; // Will fall through to MENUDOWN (if NO_VERT_SCROLL) if (!(data->flags&LVF_NO_VERT_SCROLL)) { retval=GMR_NOREUSE; data->flags|=LVF_CANCEL; break; } } else break; } else break; } // Get selection else if ((sel=listview_get_sel(cl,gadget,data,input,1))>-1 || (sel==-1 && (data->flags&LVF_NO_VERT_SCROLL))) { // Change? if (data->sel!=sel || sel==-1) { // Clear double-click data->seconds=0; // No vertical scroll? if (data->flags&LVF_NO_VERT_SCROLL) { // Drag notify? if (data->flags&LVF_DRAG_NOTIFY) { // Notify drag data->flags|=LVF_DRAG_FLAG; data->drag_sel=data->sel; // Will fall through to MENUDOWN } else break; } // Otherwise else { // Save old selection data->last_sel=data->sel; // New selection data->sel=sel; redraw=1; break; } } else break; } else break; } // Right button does cancel case MENUDOWN: { // Gadget processing finished retval=GMR_NOREUSE; data->flags|=LVF_CANCEL; // Show selected? if (data->flags&LVF_SHOW_SELECTED) { // Restore last selection data->last_sel=data->sel; data->sel=data->last_selection; // Does top need to change? if (data->top!=data->last_top) { short item; data->top=data->last_top; data->last_sel=-1; for (data->top_item=data->labels->lh_Head,item=0; data->top_item->ln_Succ && item<data->top; data->top_item=data->top_item->ln_Succ,item++); } redraw=1; } } break; } } // Or a timer event else if (input->gpi_IEvent->ie_Class==IECLASS_TIMER) { short sel; // Get selection if ((sel=listview_get_sel(cl,gadget,data,input,2))>-1) { // Change? if (data->sel!=sel) { // Save old selection data->last_sel=data->sel; // New selection data->sel=sel; // Do we have to scroll? if (sel<data->top) { if (data->top>0) { // Scroll up --data->top; data->top_item=data->top_item->ln_Pred; // Redraw the list data->last_sel=-1; redraw=1; } } else if (sel>=data->top+data->lines) { if (data->top+data->lines<data->count) { // Scroll down ++data->top; data->top_item=data->top_item->ln_Succ; // Redraw the list data->last_sel=-1; redraw=1; } } else redraw=1; } } } } // Redraw needed? if (redraw) { struct RastPort *rp; // Get rastport if ((rp=ObtainGIRPort(input->gpi_GInfo))) { // Send redraw DoMethod(obj,GM_RENDER,input->gpi_GInfo,rp,GREDRAW_UPDATE); ReleaseGIRPort(rp); } } } break; // Resize case GM_RESIZE: // Handle the resize listview_resize(cl,gadget,data,(struct gpResize *)msg); break; // Unknown method default: retval=DoSuperMethodA(cl,obj,msg); break; } return retval; }
void ReadDefinitions(OBJECT *token, OBJECT encl, unsigned char res_type) { OBJECT t, res, res_target, export_list, import_list, link, y, z; OBJECT curr_encl; BOOLEAN compulsory_par, has_import_encl; t = *token; while( res_type==LOCAL || is_string(t, KW_NAMED) || is_string(t, KW_IMPORT) ) { curr_encl = encl; if( is_string(t, KW_LANGDEF) ) { ReadLangDef(encl); t = LexGetToken(); continue; /* next definition */ } else if( type(t) == PREPEND || type(t) == SYS_PREPEND ) { ReadPrependDef(type(t), encl); Dispose(t); t = LexGetToken(); continue; /* next definition */ } else if( type(t) == INCG_REPEATED || type(t) == SINCG_REPEATED ) { ReadIncGRepeatedDef(type(t), encl); Dispose(t); t = LexGetToken(); continue; /* next definition */ } else if( type(t) == DATABASE || type(t) == SYS_DATABASE ) { ReadDatabaseDef(type(t), encl); Dispose(t); t = LexGetToken(); continue; /* next definition */ } if( !is_string(t, KW_DEF) && !is_string(t, KW_MACRO) && !is_string(t, KW_NAMED) && !is_string(t, KW_IMPORT) && !is_string(t, KW_EXTEND) && !is_string(t, KW_EXPORT) ) break; /* get import or extend list and change scope appropriately */ BodyParNotAllowed(); New(import_list, ACAT); has_import_encl = FALSE; if( is_string(t, KW_IMPORT) ) { Dispose(t); t = LexGetToken(); while( type(t) == CLOSURE || (type(t)==WORD && !is_string(t,KW_EXPORT) && !is_string(t,KW_DEF) && !is_string(t, KW_MACRO) && !is_string(t, KW_NAMED)) ) { if( type(t) == CLOSURE ) { if( type(actual(t)) == LOCAL ) { /* *** letting this through now if( res_type == NPAR && has_par(actual(t)) ) { Error(5, 46, "named parameter import %s has parameters", WARN, &fpos(t), SymName(actual(t))); } else { *** */ PushScope(actual(t), FALSE, TRUE); if( actual(t) == encl ) has_import_encl = TRUE; Link(import_list, t); /* *** } *** */ } else { Error(5, 26, "import name expected here", WARN, &fpos(t)); Dispose(t); } } else { Error(5, 27, "import %s not in scope", WARN, &fpos(t), string(t)); Dispose(t); } t = LexGetToken(); } } else if( is_string(t, KW_EXTEND) ) { Dispose(t); t = LexGetToken(); while( type(t) == CLOSURE || (type(t)==WORD && !is_string(t,KW_EXPORT) && !is_string(t,KW_DEF) && !is_string(t, KW_MACRO)) ) { if( type(t) == CLOSURE ) { if( imports(actual(t)) != nilobj ) { Error(5, 48, "%s has %s clause, so cannot be extended", WARN, &fpos(t), SymName(actual(t)), KW_IMPORT); } else if( type(actual(t)) == LOCAL ) { PushScope(actual(t), FALSE, FALSE); curr_encl = actual(t); debug1(DRD, D, " curr_encl = %s", SymName(curr_encl)); Link(import_list, t); } else { Error(5, 28, "%s symbol name expected here", WARN, &fpos(t), KW_EXTEND); Dispose(t); } } else { Error(5, 29, "extend symbol %s not in scope", WARN,&fpos(t),string(t)); Dispose(t); } t = LexGetToken(); } } /* get export list and store for setting visible flags below */ New(export_list, ACAT); if( is_string(t, KW_EXPORT) ) { Dispose(t); SuppressScope(); t = LexGetToken(); while( is_word(type(t)) && !is_string(t, KW_DEF) && !is_string(t, KW_IMPORT) && !is_string(t, KW_MACRO) && !is_string(t, KW_EXTEND) ) { Link(export_list, t); t = LexGetToken(); } UnSuppressScope(); } if( res_type == LOCAL && !is_string(t, KW_DEF) && !is_string(t, KW_MACRO) ) { Error(5, 30, "keyword %s or %s expected here", WARN, &fpos(t), KW_DEF, KW_MACRO); break; } if( res_type == NPAR && !is_string(t, KW_NAMED) ) { Error(5, 31, "keyword %s expected here", WARN, &fpos(t), KW_NAMED); break; } if( is_string(t, KW_MACRO) ) { if( Down(export_list) != export_list ) Error(5, 32, "ignoring export list of macro", WARN, &fpos(t)); res = ReadMacro(&t, curr_encl, encl); } else { SuppressScope(); Dispose(t); t = LexGetToken(); /* check for compulsory keyword */ if( res_type == NPAR && is_string(t, KW_COMPULSORY) ) { compulsory_par = TRUE; Dispose(t); t = LexGetToken(); } else compulsory_par = FALSE; /* find name of symbol and insert it */ if( !is_word(type(t)) ) { Error(5, 33, "symbol name expected here", WARN, &fpos(t)); debug1(ANY, D, "offending type is %s", Image(type(t))); UnSuppressScope(); *token = t; return; } res = InsertSym(string(t), res_type, &fpos(t), DEFAULT_PREC, FALSE, FALSE, 0, curr_encl, nilobj); if( curr_encl != encl ) visible(res) = TRUE; if( has_import_encl ) { imports_encl(res) = TRUE; debug1(DCE, D, " setting import_encl(%s) to TRUE", SymName(res)); } if( compulsory_par ) { has_compulsory(encl)++; is_compulsory(res) = TRUE; } Dispose(t); t = LexGetToken(); /* find alternative names for this symbol */ while( is_word(type(t)) && !is_string(t, KW_NAMED) && !is_string(t, KW_IMPORT) && !is_string(t, KW_FORCE) && !is_string(t, KW_INTO) && !is_string(t, KW_HORIZ) && !is_string(t, KW_PRECEDENCE) && !is_string(t, KW_ASSOC) && !is_string(t, KW_LEFT) && !is_string(t, KW_RIGHT) && !is_string(t, KW_BODY) && !is_string(t, KW_LBR) && !is_string(t, KW_BEGIN) ) { InsertAlternativeName(string(t), res, &fpos(t)); Dispose(t); t = LexGetToken(); } /* find force, if any */ if( is_string(t, KW_FORCE) ) { force_target(res) = TRUE; Dispose(t); t = LexGetToken(); if( !is_string(t, KW_INTO) && !is_string(t, KW_HORIZ) ) Error(5, 34, "%s expected here", WARN, &fpos(t), KW_INTO); } /* find horizontally, if any */ if( is_string(t, KW_HORIZ) ) { horiz_galley(res) = COLM; Dispose(t); t = LexGetToken(); /* *** want to allow KW_HORIZ with @Target form now if( !is_string(t, KW_INTO) ) Error(5, 35, "%s expected here", WARN, &fpos(t), KW_INTO); *** */ } /* find into clause, if any */ res_target = nilobj; if( is_string(t, KW_INTO) ) { UnSuppressScope(); Dispose(t); t = LexGetToken(); if( type(t) != LBR ) { Error(5, 36, "%s expected here", WARN, &fpos(t), KW_LBR); debug1(ANY, D, "offending type is %s", Image(type(t))); UnSuppressScope(); *token = t; return; } res_target = Parse(&t, curr_encl, FALSE, FALSE); SuppressScope(); if( t == nilobj ) t = LexGetToken(); } /* find precedence clause, if any */ if( is_string(t, KW_PRECEDENCE) ) { int prec = 0; UnSuppressScope(); Dispose(t); t = LexGetToken(); while( type(t) == WORD && decimaldigit(string(t)[0]) ) { prec = prec * 10 + digitchartonum(string(t)[0]); Dispose(t); t = LexGetToken(); } SuppressScope(); if( prec < MIN_PREC ) { Error(5, 37, "precedence is too low (%d substituted)", WARN, &fpos(t), MIN_PREC); prec = MIN_PREC; } else if( prec > MAX_PREC ) { Error(5, 38, "precedence is too high (%d substituted)", WARN, &fpos(t), MAX_PREC); prec = MAX_PREC; } precedence(res) = prec; } /* find associativity clause, if any */ if( is_string(t, KW_ASSOC) ) { UnSuppressScope(); Dispose(t); t = LexGetToken(); if( is_string(t, KW_LEFT) ) right_assoc(res) = FALSE; else if( !is_string(t, KW_RIGHT) ) Error(5, 39, "associativity altered to %s", WARN, &fpos(t), KW_RIGHT); SuppressScope(); Dispose(t); t = LexGetToken(); } /* find left parameter, if any */ if( is_string(t, KW_LEFT) ) { Dispose(t); t = LexGetToken(); if( type(t) != WORD ) { Error(5, 40, "cannot find %s parameter name", WARN, &fpos(t), KW_LEFT); debug1(ANY, D, "offending type is %s", Image(type(t))); UnSuppressScope(); *token = t; return; } InsertSym(string(t), LPAR, &fpos(t), DEFAULT_PREC, FALSE, FALSE, 0, res, nilobj); Dispose(t); t = LexGetToken(); } /* find named parameters, if any */ UnSuppressScope(); ReadDefinitions(&t, res, NPAR); /* find right or body parameter, if any */ if( is_string(t, KW_RIGHT) || is_string(t, KW_BODY) ) { has_body(res) = is_string(t, KW_BODY); SuppressScope(); Dispose(t); t = LexGetToken(); if( type(t) != WORD ) { Error(5, 41, "cannot find %s parameter name", WARN,&fpos(t),KW_RIGHT); debug1(ANY, D, "offending type is %s", Image(type(t))); UnSuppressScope(); *token = t; return; } InsertSym(string(t), RPAR, &fpos(t), DEFAULT_PREC, FALSE, FALSE, 0, res, nilobj); UnSuppressScope(); Dispose(t); t = LexGetToken(); } /* read local definitions and body */ if( res_target != nilobj ) InsertSym(KW_TARGET, LOCAL, &fpos(res_target), DEFAULT_PREC, FALSE, FALSE, 0, res, res_target); if( type(t) == WORD && StringEqual(string(t), KW_LBR) ) { z = NewToken(LBR, &fpos(t), 0, 0, LBR_PREC, StartSym); Dispose(t); t = z; } else if( type(t) == WORD && StringEqual(string(t), KW_BEGIN) ) { z = NewToken(BEGIN, &fpos(t), 0, 0, BEGIN_PREC, StartSym); Dispose(t); t = z; } else if( type(t) != LBR && type(t) != BEGIN ) Error(5, 42, "opening left brace or @Begin of %s expected", FATAL, &fpos(t), SymName(res)); if( type(t) == BEGIN ) actual(t) = res; PushScope(res, FALSE, FALSE); BodyParAllowed(); sym_body(res) = Parse(&t, res, TRUE, FALSE); /* set visible flag of the exported symbols */ for( link=Down(export_list); link != export_list; link=NextDown(link) ) { Child(y, link); z = SearchSym(string(y), StringLength(string(y))); if( z == nilobj || enclosing(z) != res ) Error(5, 43, "exported symbol %s is not defined in %s", WARN, &fpos(y), string(y), SymName(res)); else if( has_body(res) && type(z) == RPAR ) Error(5, 44, "body parameter %s may not be exported", WARN, &fpos(y), string(y)); else if( visible(z) ) Error(5, 45, "symbol %s exported twice", WARN, &fpos(y), string(y)); else visible(z) = TRUE; } DisposeObject(export_list); /* pop scope of res */ PopScope(); } /* pop import scopes and store imports in sym tab */ for( link=Down(import_list); link != import_list; link=NextDown(link) ) { PopScope(); } if( Down(import_list) == import_list || curr_encl != encl ) { DisposeObject(import_list); import_list = nilobj; } else { imports(res) = import_list; } BodyParAllowed(); if( t == nilobj ) t = LexGetToken(); } /* end while */ *token = t; return; } /* end ReadDefinitions */
// Add or remove fuel gauge void lister_set_gauge(Lister *lister,BOOL refresh) { BOOL want,change=0; // If lister is closed, problem is moot if (!lister->window || (lister->more_flags&LISTERF_TITLEBARRED)) return; // See if lister wants a gauge want=lister_want_gauge(lister); // Does lister have gauge and we don't want it to? if (lister->gauge_gadget && !want) { // Remove the gadget RemoveGList(lister->window,lister->gauge_gadget,1); // Free gadget DisposeObject((Object *)lister->gauge_gadget); lister->gauge_gadget=0; // Fix border width lister->window->BorderLeft=lister->old_border_left; // Free pens lister_init_colour(lister,ENVCOL_GAUGE,TRUE); // Set change flag change=1; } // Or, do we not have it but want it? else if (!lister->gauge_gadget && want) { // Initialise pens lister_init_colour(lister,ENVCOL_GAUGE,FALSE); // Create gauge if ((lister->gauge_gadget=(struct Gadget *) NewObject( 0, "dopusgaugeclass", GA_ID,GAD_GAUGE, GA_Left,0, GA_Top,lister->window->BorderTop, GA_Width,lister->window->BorderRight, GA_RelHeight,-lister->window->BorderTop-lister->window->BorderBottom+3, GA_LeftBorder,TRUE, DGG_FillPen,lister->lst_Colours[ENVCOL_GAUGE].cr_Pen[0], DGG_FillPenAlert,lister->lst_Colours[ENVCOL_GAUGE].cr_Pen[1], TAG_END))) { // Fix border width lister->window->BorderLeft=lister->window->BorderRight; // Add gauge to window after parent button AddGList(lister->window,lister->gauge_gadget,-1,1,0); RefreshGList(lister->gauge_gadget,lister->window,0,1); // Set change flag change=1; } // Failed else { // Free pens lister_init_colour(lister,ENVCOL_GAUGE,TRUE); } } // Changed? if (change) { // Fix left border related things lister->window->GZZWidth=lister->window->Width-lister->window->BorderLeft-lister->window->BorderRight; lister->parent_button.Width=lister->window->BorderLeft; } // Changed and need to refresh? if (change && refresh) { // Initialise and refresh lister_init_display(lister); lister_refresh(lister,LREFRESH_FULL|LREFRESH_FULL_ICON); // If the path field is added, refresh it if (lister->path_field && lister->flags&LISTERF_PATH_FIELD) { struct gpResize resize; // Fill out resize packet resize.MethodID=GM_RESIZE; resize.gpr_GInfo=0; resize.gpr_RPort=0; resize.gpr_Size.Left=lister->window->BorderLeft; resize.gpr_Size.Top=-(lister->window->BorderBottom+FIELD_FONT->tf_YSize+4); resize.gpr_Size.Width=-(lister->window->BorderLeft+lister->window->BorderRight); resize.gpr_Size.Height=FIELD_FONT->tf_YSize+4; resize.gpr_Redraw=0; resize.gpr_Window=lister->window; resize.gpr_Requester=0; // Tell string gadget to resize DoMethodA((Object *)lister->path_field,(Msg)&resize); // Erase behind path field SetAPen(lister->window->RPort,3); RectFill( lister->window->RPort, lister->window->BorderLeft, lister->window->Height+lister->path_field->TopEdge-2, lister->window->Width-lister->window->BorderRight-1, lister->window->Height+lister->path_field->TopEdge+lister->path_field->Height+1); // Refresh path field RefreshGList(lister->path_field,lister->window,0,1); } // Refresh the window frame RefreshWindowFrame(lister->window); // Do we have the gauge? if (lister->gauge_gadget) { // Refresh title and gauge lister_show_name(lister); } } }
void FlushGalley(OBJECT hd) { OBJECT dest; /* the target galley hd empties into */ OBJECT dest_index; /* the index of dest */ OBJECT inners; /* list of galleys and PRECEDES to flush */ OBJECT link, y; /* for scanning through the components of hd */ int dim; /* direction of galley */ CONSTRAINT dest_par_constr; /* the parallel size constraint on dest */ CONSTRAINT dest_perp_constr; /* the perpendicular size constraint on dest */ int pb, pf, f; /* candidate replacement sizes for dest */ OBJECT dest_encl; /* the VCAT or ACAT enclosing dest, if any */ int dest_side; /* if dest_encl != nilobj, side dest is on */ BOOLEAN need_adjust; /* TRUE as soon as dest_encl needs adjusting */ FULL_LENGTH dest_back, dest_fwd; /* the current size of dest_encl or dest */ FULL_LENGTH frame_size; /* the total constraint of dest_encl */ OBJECT prec_gap; /* the gap preceding dest if any else nilobj */ OBJECT prec_def; /* the component preceding dest, if any */ OBJECT succ_gap; /* the gap following dest if any else nilobj */ OBJECT succ_def; /* the component following dest, if any */ OBJECT stop_link; /* most recently seen gap link of hd */ FULL_LENGTH stop_back; /* back(dest_encl) incl all before stop_link */ FULL_LENGTH stop_fwd; /* fwd(dest_encl) incl. all before stop_link */ FULL_LENGTH stop_perp_back; /* back(dest_encl) in other direction */ FULL_LENGTH stop_perp_fwd; /* fwd(dest_encl) in other direction */ BOOLEAN prnt_flush; /* TRUE when the parent of hd needs a flush */ BOOLEAN target_is_internal; /* TRUE if flushing into an internal target */ BOOLEAN headers_seen; /* TRUE if a header is seen at all */ OBJECT zlink, z, tmp, prnt; int attach_status; BOOLEAN remove_target; OBJECT why; FULL_LENGTH perp_back, perp_fwd; /* current perp size of dest_encl */ debug1(DGF, D, "[ FlushGalley %s (hd)", SymName(actual(hd))); prnt_flush = FALSE; dim = gall_dir(hd); RESUME: assert( type(hd) == HEAD, "FlushGalley: type(hd) != HEAD!" ); debug1(DGF, D, " resuming FlushGalley %s, hd =", SymName(actual(hd))); ifdebugcond(DGF, DD, actual(hd) == nilobj, DebugGalley(hd, nilobj, 4)); assert( Up(hd) != hd, "FlushGalley: resume found no parent to hd!" ); /*@@************************************************************************/ /* */ /* The first step is to examine the parent of galley hd to determine the */ /* status of the galley. If this is not suitable for flushing, we do */ /* what we can to change the status. If still no good, return; so if */ /* this code does not return, then the galley is ready to flush into a */ /* destination in the normal way, and the following variables are set: */ /* */ /* dest_index the parent of the galley and index of its destination */ /* dest the destination of the galley, a @Galley object */ /* */ /***************************************************************************/ Parent(dest_index, Up(hd)); switch( type(dest_index) ) { case DEAD: /* the galley has been killed off while this process was sleeping */ debug1(DGF, D, "] FlushGalley %s returning (DEAD)", SymName(actual(hd))); return; case UNATTACHED: /* the galley is currently not attached to a destination */ attach_status = AttachGalley(hd, &inners, &y); debug1(DGF, DD, " ex-AttachGalley inners: %s", DebugInnersNames(inners)); Parent(dest_index, Up(hd)); switch( attach_status ) { case ATTACH_KILLED: assert(inners==nilobj, "FlushGalley/ATTACH_KILLED: inners!=nilobj!"); debug1(DGF, D, "] FlushGalley %s returning (ATTACH_KILLED)", SymName(actual(hd))); debug1(DGF, D, " prnt_flush = %s", bool(prnt_flush)); return; case ATTACH_INPUT: ParentFlush(prnt_flush, dest_index, FALSE); assert(inners==nilobj, "FlushGalley/ATTACH_INPUT: inners!=nilobj!"); debug1(DGF, D, "] FlushGalley %s returning (ATTACH_INPUT)", SymName(actual(hd))); return; case ATTACH_NOTARGET: ParentFlush(prnt_flush, dest_index, FALSE); assert(inners==nilobj, "FlushGalley/ATTACH_NOTARG: inners!=nilobj!"); debug1(DGF, D, "] FlushGalley %s returning (ATTACH_NOTARGET)", SymName(actual(hd))); return; case ATTACH_SUSPEND: /* AttachGalley only returns inners here if they really need to */ /* be flushed; in particular the galley must be unsized before */ if( inners != nilobj ) { debug0(DGF, DD, " calling FlushInners() from FlushGalley (a)"); FlushInners(inners, nilobj); goto RESUME; } stop_link = nilobj; goto SUSPEND; /* nb y will be set by AttachGalley in this case */ case ATTACH_NULL: /* hd will have been linked to the unexpanded target in this case */ remove_target = (actual(actual(dest_index)) == whereto(hd)); if( force_gall(hd) ) { /* if hd is a forcing galley, close all predecessors */ debug3(DGA, D, " forcing ATTACH_NULL case for %s into %s (%s)", SymName(actual(hd)), SymName(whereto(hd)), remove_target ? "remove_target" : "not remove_target"); Parent(prnt, Up(dest_index)); if( !non_blocking(dest_index) && remove_target ) { /* *** prnt_flush = TRUE; *** */ prnt_flush = non_blocking(dest_index) = TRUE; } FreeGalley(prnt, Up(dest_index), &inners, Up(dest_index), whereto(hd)); } else { debug3(DGA, D, " non-force ATTACH_NULL case for %s into %s (%s)", SymName(actual(hd)), SymName(whereto(hd)), remove_target ? "remove_target" : "not remove_target"); if( blocked(dest_index) && remove_target ) prnt_flush = TRUE; } DetachGalley(hd); KillGalley(hd, TRUE); if( inners != nilobj ) { debug0(DGF, DD, " calling FlushInners() from FlushGalley (b)"); FlushInners(inners, nilobj); } else ParentFlush(prnt_flush, dest_index, remove_target); debug0(DGF, D, "] FlushGalley returning ATTACH_NULL"); return; case ATTACH_ACCEPT: /* if hd is a forcing galley, or actual(dest_index) is */ /* @ForceGalley, then close all predecessors */ if( force_gall(hd) || actual(actual(dest_index)) == ForceGalleySym ) { Parent(prnt, Up(dest_index)); debug1(DGA, D, " forcing ATTACH_ACCEPT case for %s", SymName(actual(hd))); /* debug0(DGA, DD, " force: prnt ="); */ /* ifdebug(DGA, DD, DebugObject(prnt)); */ /* debug1(DGA, D," calling FreeGalley from FlushGalley(%s)", */ /* SymName(actual(hd))); */ if( !non_blocking(dest_index) ) prnt_flush = TRUE; /* bug fix */ FreeGalley(prnt, Up(dest_index), &inners, Up(dest_index), whereto(hd)); /* debug0(DGA, DD, " force: after FreeGalley, prnt ="); */ /* ifdebug(DGA, DD, DebugObject(prnt)); */ } else prnt_flush = prnt_flush || blocked(dest_index); debug1(DGF, DD, " force: prnt_flush = %s", bool(prnt_flush)); if( inners != nilobj ) { debug0(DGF, DD, " calling FlushInners() from FlushGalley (c)"); FlushInners(inners, nilobj); } goto RESUME; default: assert(FALSE, "FlushGalley: attach_status"); break; } break; case RECEIVING: if( actual(actual(dest_index)) == InputSym ) { ParentFlush(prnt_flush, dest_index, FALSE); debug1(DGF, D, "] FlushGalley %s retn, input", SymName(actual(hd))); return; } break; default: assert1(FALSE, "FlushGalley: dest_index", Image(type(dest_index))); break; } dest = actual(dest_index); if( underline(dest) == UNDER_UNDEF ) underline(dest) = UNDER_OFF; target_is_internal = (dim==ROWM && !external_ver(dest)) || (dim==COLM && !external_hor(dest)); headers_seen = FALSE; debug1(DGF, DD, " dest_index: %s", EchoObject(dest_index)); /*@@************************************************************************/ /* */ /* The second step is to examine the components of the galley one by one */ /* to determine if they can be promoted. Each component has the format */ /* */ /* { <index> } <object> */ /* */ /* and is always followed by a gap object (except the last component). */ /* An index indicates that the following object has some interesting */ /* feature, and it points to that feature inside the object. There are */ /* two possible actions for each component, in addition to accepting it: */ /* */ /* REJECT: The component does not fit, so detach the galley */ /* SUSPEND: The component is incomplete; go to sleep and wait */ /* */ /***************************************************************************/ stop_link = dest_encl = inners = nilobj; need_adjust = FALSE; /***************************************************************************/ /* */ /* Loop invariant */ /* */ /* The children of hd up to but not including Child(link) have been */ /* examined and pronounced to be promotable, if unbreakable gaps are */ /* ignored. When unbreakable gaps are taken into account, the most */ /* recent gap where a break is possible is at Child(stop_link), or */ /* nowhere if stop_link == nilobj. */ /* */ /* Case 1: target_is_internal == FALSE */ /* */ /* If this flag is FALSE, it means that the target of this galley is */ /* external. Consequently, there is no need to calculate sizes because */ /* there is no constraint on them. Also, a REJECT action is impossible */ /* so unbreakable gaps are no impediment. Variable dest_encl is nilobj. */ /* */ /* Case 2: target_is_internal == TRUE */ /* */ /* If this flag is TRUE, it means that the target of this galley is */ /* internal. Consequently, sizes need to be calculated, and unbreakable */ /* gaps need to be taken into account. Variable dest_encl may be not */ /* nilobj, in which case the following variables are defined: */ /* */ /* dest_encl the object enclosing dest (which must exist) */ /* prec_gap gap object preceding dest (which must exist) */ /* prec_def first definite object preceding dest (must exist) */ /* dest_back back(dest_encl) including effect of accepted compts */ /* dest_fwd fwd(dest_encl) including effect of accepted compts */ /* dest_side BACK or FWD, i.e. which side of the mark dest is on */ /* dest_par_constr the parallel size constraint on dest */ /* dest_perp_constr the perpendicular size constraint on dest */ /* frame_size size of frame enclosing dest_encl */ /* perp_back back(dest_encl) in other direction, incl accepteds */ /* perp_fwd fwd(dest_encl) in other direction, incl accepteds */ /* */ /* if dest_encl is nilobj, these variables are not defined. */ /* */ /* If stop_link is non-nilobj, then in the internal case dest_encl must */ /* be non-nilobj, and the following variables are defined: */ /* */ /* stop_back back(dest_encl) including all before stop_link */ /* stop_fwd fwd(dest_encl) including all before stop_link */ /* stop_perp_back back(dest_encl) in other direction */ /* stop_perp_fwd fwd(dest_encl) in other direction */ /* */ /* need_adjust is true if at least one definite component has been */ /* accepted for promotion and the destination is internal; hence, */ /* dest_encl is defined and its size needs to be adjusted. */ /* */ /* inners is the set of all PRECEDES and UNATTACHED indexes found. */ /* */ /***************************************************************************/ for( link = Down(hd); link != hd; link = NextDown(link) ) { Child(y, link); if( type(y) == SPLIT ) Child(y, DownDim(y, dim)); debug2(DGF, DD, " examining %s %s", Image(type(y)), EchoObject(y)); switch( type(y) ) { case GAP_OBJ: underline(y) = underline(dest); prec_gap = y; if( target_is_internal ) { /* *** not necessarily true assert( dest_encl != nilobj, "FlushGalley/GAP_OBJ: dest_encl!" ); *** */ if( dest_encl != nilobj && !nobreak(gap(prec_gap)) ) { stop_link = link; stop_back = dest_back; stop_fwd = dest_fwd; stop_perp_back = perp_back; stop_perp_fwd = perp_fwd; } } else stop_link = link; if( !join(gap(y)) ) seen_nojoin(hd) = TRUE; break; case SCALE_IND: case COVER_IND: case EXPAND_IND: case GALL_PREC: case GALL_FOLL: case GALL_FOLL_OR_PREC: case GALL_TARG: case CROSS_PREC: case CROSS_FOLL: case CROSS_FOLL_OR_PREC: case CROSS_TARG: case PAGE_LABEL_IND: underline(y) = underline(dest); break; case PRECEDES: case UNATTACHED: if( inners == nilobj ) New(inners, ACAT); Link(inners, y); break; case RECEIVING: case RECEPTIVE: goto SUSPEND; case FOLLOWS: Child(tmp, Down(y)); if( Up(tmp) == LastUp(tmp) ) { link = PrevDown(link); DisposeChild(NextDown(link)); break; } Parent(tmp, Up(tmp)); assert(type(tmp) == PRECEDES, "Flush: PRECEDES!"); switch( CheckComponentOrder(tmp, dest_index) ) { case CLEAR: DeleteNode(tmp); link = PrevDown(link); DisposeChild(NextDown(link)); break; case PROMOTE: break; case BLOCK: goto SUSPEND; case CLOSE: if( opt_components(hd) != nilobj ) { DisposeObject(opt_components(hd)); opt_components(hd) = nilobj; debug2(DOG, D, "FlushGalley(%s) de-optimizing %s", "(CLOSE problem)", SymName(actual(hd))); } debug1(DGF, DD, " reject (a) %s", EchoObject(y)); goto REJECT; } break; case BEGIN_HEADER: case END_HEADER: case SET_HEADER: case CLEAR_HEADER: /* do nothing except take note, until actually promoted out of here */ headers_seen = TRUE; break; case NULL_CLOS: case PAGE_LABEL: case WORD: case QWORD: case ONE_COL: case ONE_ROW: case WIDE: case HIGH: case HSHIFT: case VSHIFT: case HSCALE: case VSCALE: case HCOVER: case VCOVER: case HCONTRACT: case VCONTRACT: case HLIMITED: case VLIMITED: case HEXPAND: case VEXPAND: case START_HVSPAN: case START_HSPAN: case START_VSPAN: case HSPAN: case VSPAN: case ROTATE: case BACKGROUND: case SCALE: case KERN_SHRINK: case INCGRAPHIC: case SINCGRAPHIC: case PLAIN_GRAPHIC: case GRAPHIC: case LINK_SOURCE: case LINK_DEST: case ACAT: case HCAT: case VCAT: case ROW_THR: case CLOSURE: case CROSS: case FORCE_CROSS: underline(y) = underline(dest); if( dim == ROWM ) { /* make sure y is not joined to a target below (vertical case only) */ for( zlink = NextDown(link); zlink != hd; zlink = NextDown(zlink) ) { Child(z, zlink); switch( type(z) ) { case RECEPTIVE: case RECEIVING: y = z; goto SUSPEND; case GAP_OBJ: if( !join(gap(z)) ) zlink = PrevDown(hd); break; default: break; } } /* try vertical hyphenation before anything else */ if( type(y) == HCAT ) VerticalHyphenate(y); } /* check size constraint */ if( target_is_internal ) { /* initialise dest_encl etc if not done yet */ if( dest_encl == nilobj ) { assert( UpDim(dest,1-dim) == UpDim(dest,dim), "FlushG: UpDims!" ); /* *** weird old code, trying for UpDim(dest, ROWM)? Parent(dest_encl, NextDown(Up(dest))); *** */ Parent(dest_encl, Up(dest)); debug4(DGF, DD, " flush dest = %s %s, dest_encl = %s %s", Image(type(dest)), EchoObject(dest), Image(type(dest_encl)), EchoObject(dest_encl)); assert( (dim==ROWM && type(dest_encl)==VCAT) || (dim==COLM && type(dest_encl)==ACAT), "FlushGalley: dest != VCAT or ACAT!" ); SetNeighbours(Up(dest), FALSE, &prec_gap, &prec_def, &succ_gap, &succ_def, &dest_side); assert(prec_gap != nilobj || is_indefinite(type(y)), "FlushGalley: prec_gap == nilobj && !is_indefinite(type(y))!" ); assert(succ_gap == nilobj, "FlushGalley: succ_gap != nilobj!" ); assert(dest_side == FWD || is_indefinite(type(y)), "FlushGalley: dest_side != FWD || !is_indefinite(type(y))!"); dest_back = back(dest_encl, dim); dest_fwd = fwd(dest_encl, dim); perp_back = back(dest_encl, 1-dim); perp_fwd = fwd(dest_encl, 1-dim); Constrained(dest_encl, &dest_par_constr, dim, &why); Constrained(dest_encl, &dest_perp_constr, 1-dim, &why); debug1(DGF, DD, " setting dest_perp_constr = %s", EchoConstraint(&dest_perp_constr)); frame_size = constrained(dest_par_constr) ? bfc(dest_par_constr) :0; } if( !is_indefinite(type(y)) ) { ifdebugcond(DGF, DD, mode(gap(prec_gap)) == NO_MODE, DebugGalley(hd, y, 4)); /* calculate parallel effect of adding y to dest */ f = dest_fwd + fwd(y, dim) - fwd(prec_def, dim) + ActualGap(fwd(prec_def, dim), back(y, dim), fwd(y, dim), &gap(prec_gap), frame_size, dest_back + dest_fwd - fwd(prec_def, dim)); debug5(DGF, DD, " f = %s + %s - %s + %s (prec_gap %s)", EchoLength(dest_fwd), EchoLength(fwd(y, dim)), EchoLength(fwd(prec_def, dim)), EchoLength( ActualGap(fwd(prec_def, dim), back(y, dim), fwd(y, dim), &gap(prec_gap), frame_size, dest_back + dest_fwd - fwd(prec_def, dim)) ), EchoGap(&gap(prec_gap))); debug3(DGF, DD, " b,f: %s,%s; dest_encl: %s", EchoLength(dest_back), EchoLength(f), EchoConstraint(&dest_par_constr)); /* check new size against parallel constraint */ if( (units(gap(prec_gap))==FRAME_UNIT && width(gap(prec_gap)) > FR) || !FitsConstraint(dest_back, f, dest_par_constr) || (opt_components(hd) != nilobj && opt_comps_permitted(hd)<=0) ) { if( opt_components(hd) != nilobj ) { OBJECT z; /* record the size of this just-completed target area for hd */ New(z, WIDE); CopyConstraint(constraint(z), dest_par_constr); Link(opt_constraints(hd), z); ifdebug(DOG, D, debug2(DOG, D, "FlushGalley(%s) adding constraint %s", SymName(actual(hd)), EchoConstraint(&constraint(z))); if( units(gap(prec_gap))==FRAME_UNIT && width(gap(prec_gap)) > FR ) { debug1(DOG, D, " prec_gap = %s", EchoGap(&gap(prec_gap))); } if( !FitsConstraint(dest_back, f, dest_par_constr) ) { debug3(DOG, D, " !FitsConstraint(%s, %s, %s)", EchoLength(dest_back), EchoLength(f), EchoConstraint(&dest_par_constr)); } if( opt_comps_permitted(hd) <= 0 ) { debug1(DOG, D, " opt_comps_permitted = %2d", opt_comps_permitted(hd)); } debug4(DOG, D, "prec_gap = %s; y = %s (%s,%s):", EchoGap(&gap(prec_gap)), Image(type(y)), EchoLength(back(y, dim)), EchoLength(fwd(y, dim))); DebugObject(y); ) /* refresh the number of components permitted into the next target */ if( opt_counts(hd) != nilobj && Down(opt_counts(hd)) != opt_counts(hd) ) { Child(z, Down(opt_counts(hd))); opt_comps_permitted(hd) += comp_count(z) - 1; DisposeChild(Up(z)); } else opt_comps_permitted(hd) = MAX_FILES; /* a large number */ debug1(DOG, D, " REJECT permitted = %2d", opt_comps_permitted(hd)); } debug1(DGF, DD, " reject (b) %s", EchoObject(y)); goto REJECT; } /* calculate perpendicular effect of adding y to dest */ if( seen_nojoin(hd) ) { pb = 0; pf = find_max(perp_fwd, size(y, 1-dim)); } else { pb = find_max(perp_back, back(y, 1-dim)); pf = find_max(perp_fwd, fwd(y, 1-dim)); } /* check new size against perpendicular constraint */ if( !FitsConstraint(pb, pf, dest_perp_constr) ) { if( opt_components(hd) != nilobj ) { DisposeObject(opt_components(hd)); opt_components(hd) = nilobj; debug1(DOG, D, "FlushGalley(%s) de-optimizing (perp problem)", SymName(actual(hd))); } if( dim == ROWM ) { Error(20, 3, "component too wide for available space", WARN, &fpos(y)); debug6(DGF, DD, " %s,%s [%s,%s] too wide for %s, y = %s", EchoLength(pb), EchoLength(pf), EchoLength(back(y, 1-dim)), EchoLength(fwd(y, 1-dim)), EchoConstraint(&dest_perp_constr), EchoObject(y)); } debug1(DGF, DD, " reject (c) %s", EchoObject(y)); goto REJECT; } /* accept definite component */ dest_fwd = f; prec_def = y; perp_back = pb; perp_fwd = pf; need_adjust = TRUE; if( opt_components(hd) != nilobj ) { opt_comps_permitted(hd)--; debug1(DOG, D, " ACCEPT permitted = %2d", opt_comps_permitted(hd)); } } /* accept indefinite component */ } /* end if( target_is_internal ) */
static Object *bitmap_new(Class *cl, Object *obj, struct pRoot_New *msg) { struct TagItem tags[] = { {aHidd_BitMap_AllocBuffer, FALSE }, {TAG_MORE , (IPTR) NULL} }; struct HIDDBitMapAmigaIntuiData *data; struct TagItem *tag, *tstate, *newTagList; BOOL ok = FALSE; struct pRoot_New new_msg; struct pHidd_BitMap_PrivateSet private_set_msg; ULONG width, height, depth, format; BOOL displayable; EnterFunc(bug("BitMapAmigaIntui::New()\n")); new_msg.mID = GetMethodID(IID_Root, moRoot_New); private_set_msg.mID = GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PrivateSet); displayable = (BOOL) GetTagData(aHidd_BitMap_Displayable, 0, msg->attrList); if(!displayable) { /* let the superclass do all work */ obj = (Object *) DoSuperMethod(cl, obj, (Msg) msg); if(obj) ok = TRUE; } else { /* aHidd_BitMap_AllocBuffer and aHidd_BitMap_Displayable must be FALSE. To make this easy first a copy of the taglist is created. In the new list Hidd_BitMap_Displayable is set to FALSE. If the taglist contains a "aHidd_BitMap_AllocBuffer" tag then ti_Data is set to FALSE else tags(see above) is connected with the new list. NOTE: If msg.attrList contains more than one "aHidd_BitMap_AllocBuffer" we have a problem. */ newTagList = CloneTagItems(msg->attrList); if(newTagList) { tag = FindTagItem(aHidd_BitMap_Displayable, newTagList); if(tag) { tag->ti_Data = FALSE; } tag = FindTagItem(aHidd_BitMap_AllocBuffer, newTagList); if(tag) { tag->ti_Data = FALSE; new_msg.attrList = newTagList; } else { tags[1].ti_Data = (IPTR) newTagList; new_msg.attrList = tags; } obj = (Object *) DoSuperMethod(cl, obj, (Msg) &new_msg); FreeTagItems(newTagList); } if(obj) { data = INST_DATA(cl, obj); /* clear all data and set some default values */ memset(data, 0, sizeof(struct HIDDBitMapAmigaIntuiData)); GetAttr(obj, aHidd_BitMap_Width, &width); GetAttr(obj, aHidd_BitMap_Height, &height); GetAttr(obj, aHidd_BitMap_Depth, &depth); GetAttr(obj, aHidd_BitMap_Format, &format); if(format == vHIDD_BitMap_Format_Planar) { /* only displayable support for planar format */ struct TagItem tags[] = { {SA_Left , 0}, {SA_Top , 0}, {SA_Width , width}, {SA_Height , height}, {SA_Depth , depth}, {TAG_SKIP , 1}, /* Use SA_DisplayID only wenn a display mode */ {SA_DisplayID, 0}, /* is specified */ {SA_Title , (ULONG) "AROS graphics hidd"}, {SA_Type , CUSTOMSCREEN}, /* Will be use later */ /* SA_Quiet , TRUE, */ /* SA_BitMap , 0 On V37 double buffering could only implemented with a custom bitmap */ {TAG_DONE, 0} }; data->screen = OpenScreenTagList(NULL, tags); if(data->screen) { struct TagItem set[] = { {aHidd_BitMap_BaseAddress, (IPTR) &data->screen->RastPort.BitMap->Planes[0]}, {aHidd_BitMap_Format , vHIDD_BitMap_Format_Planar}, {aHidd_BitMap_Displayable, TRUE }, {aHidd_BitMap_BytesPerRow, data->screen->RastPort.BitMap->BytesPerRow}, {TAG_END , 0 } }; private_set_msg.attrList = set; DoSuperMethod(cl, obj, (Msg) &private_set_msg); ok = TRUE; } /* if(data->screen) */ } /* if(format == vHIDD_BitMap_Format_Planar) */ } /* if(obj) */ } /* if(!displayable) */ /* free all on error */ if(ok == FALSE) { if(obj) DisposeObject(obj); obj = NULL; } ReturnPtr("BitMapAmigaIntui::New", Object *, obj); }
void gui_create_form_select_menu(struct gui_window *g, struct form_control *control) { struct Library *PopupMenuBase = NULL; struct PopupMenuIFace *IPopupMenu = NULL; struct Hook selectmenuhook; Object *selectmenuobj; Object *smenu = NULL; Object *currentmenu; Object *submenu = NULL; char *selectmenu_item[AMI_SELECTMENU_MAX]; char *more_label; struct form_option *opt = form_select_get_option(control, 0); int i = 0; int n = 0; if(ami_selectmenu_is_safe() == FALSE) return; if((PopupMenuBase = OpenLibrary("popupmenu.class", 0))) { IPopupMenu = (struct PopupMenuIFace *)GetInterface(PopupMenuBase, "main", 1, NULL); } if(IPopupMenu == NULL) return; ClearMem(selectmenu_item, AMI_SELECTMENU_MAX * 4); more_label = ami_utf8_easy(messages_get("More")); selectmenuhook.h_Entry = ami_popup_hook; selectmenuhook.h_SubEntry = NULL; selectmenuhook.h_Data = g; g->shared->control = control; selectmenuobj = PMMENU(form_control_get_name(control)), PMA_MenuHandler, &selectmenuhook, End; currentmenu = selectmenuobj; while(opt) { selectmenu_item[i] = ami_utf8_easy(opt->text); IDoMethod(currentmenu, PM_INSERT, NewObject(POPUPMENU_GetItemClass(), NULL, PMIA_Title, (ULONG)selectmenu_item[i], PMIA_ID, i, PMIA_CheckIt, TRUE, PMIA_Checked, opt->selected, TAG_DONE), ~0); opt = opt->next; i++; n++; if(n == AMI_SELECTMENU_PAGE_MAX) { if(submenu != NULL) { /* attach the previous submenu */ IDoMethod(smenu, PM_INSERT, NewObject(NULL, "popupmenuitem.class", PMIA_Title, more_label, PMIA_CheckIt, TRUE, PMIA_SubMenu, submenu, TAG_DONE), ~0); } submenu = NewObject(NULL, "popupmenu.class", TAG_DONE); smenu = currentmenu; currentmenu = submenu; n = 0; } if(i >= AMI_SELECTMENU_MAX) break; } if((submenu != NULL) && (n != 0)) { /* attach the previous submenu */ IDoMethod(smenu, PM_INSERT, NewObject(NULL, "popupmenuitem.class", PMIA_Title, more_label, PMIA_CheckIt, TRUE, PMIA_SubMenu, submenu, TAG_DONE), ~0); } ami_set_pointer(g->shared, GUI_POINTER_DEFAULT, false); // Clear the menu-style pointer IDoMethod(selectmenuobj, PM_OPEN, g->shared->win); /* PM_OPEN is blocking, so dispose menu immediately... */ if(selectmenuobj) DisposeObject(selectmenuobj); /* ...and get rid of popupmenu.class ASAP */ if(IPopupMenu) DropInterface((struct Interface *)IPopupMenu); if(PopupMenuBase) CloseLibrary(PopupMenuBase); /* Free the menu labels */ if(more_label) ami_utf8_free(more_label); for(i = 0; i < AMI_SELECTMENU_MAX; i++) { if(selectmenu_item[i] != NULL) { ami_utf8_free(selectmenu_item[i]); selectmenu_item[i] = NULL; } } }
int main(void) { Object *app, *win, *iconCon, *vert, *horiz; Object *strip; struct MUI_CustomClass *iconContainerClass; BOOL running=TRUE; ULONG signals=0; struct Screen *screen; struct NewMenu *menuDat; struct TagItem icTags[6]; ULONG inputResult; MUIMasterBase=OpenLibrary("muimaster.library", 0); if(!MUIMasterBase) printf("could not open muimaster.library\n"); DesktopBase=OpenLibrary("desktop.library", 0); if(!DesktopBase) printf("could not open desktop.library\n"); menuDat=BuildDesktopMenus(); if(!menuDat) kprintf("EEK! EEKK! Menu ERROR!!!\n"); screen=LockPubScreen(NULL); horiz=PropObject, MUIA_Prop_Horiz, TRUE, MUIA_Prop_Entries, 0, MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Bottom, End; vert=PropObject, MUIA_Prop_Horiz, FALSE, MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Right, End; icTags[0].ti_Tag=MUIA_InnerLeft; icTags[0].ti_Data=0; icTags[1].ti_Tag=MUIA_InnerTop; icTags[1].ti_Data=0; icTags[2].ti_Tag=MUIA_InnerBottom; icTags[2].ti_Data=0; icTags[3].ti_Tag=MUIA_InnerRight; icTags[3].ti_Data=0; icTags[4].ti_Tag=MUIA_FillArea; icTags[4].ti_Data=FALSE; // icTags[1].ti_Tag=ICOA_Directory; // icTags[1].ti_Data="C:"; // icTags[2].ti_Tag=ICA_VertScroller; // icTags[2].ti_Data=vert; // icTags[3].ti_Tag=ICA_HorizScroller; // icTags[3].ti_Data=horiz; icTags[5].ti_Tag=TAG_END; icTags[5].ti_Data=0; kprintf("here1\n"); app=ApplicationObject, SubWindow, win=WindowObject, MUIA_Window_Backdrop, TRUE, MUIA_Window_Borderless, TRUE, MUIA_Window_CloseGadget, FALSE, MUIA_Window_DepthGadget, FALSE, MUIA_Window_SizeGadget, FALSE, MUIA_Window_DragBar, FALSE, MUIA_Window_LeftEdge, 0, MUIA_Window_TopEdge, screen->BarHeight+1, MUIA_Window_Width, screen->Width, MUIA_Window_Height, screen->Height-screen->BarHeight-1, MUIA_Window_Menustrip, strip=MUI_MakeObject(MUIO_MenustripNM, menuDat, 0), // MUIA_Window_UseBottomBorderScroller, TRUE, // MUIA_Window_UseRightBorderScroller, TRUE, MUIA_Window_EraseArea, FALSE, WindowContents, iconCon=CreateDesktopObjectA(CDO_Desktop, icTags), End, End; if(app) { DoMethod(win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit); // these are here temporarily.. DoMethod(vert, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, iconCon, 3, MUIM_Set, ICA_ScrollToVert, MUIV_TriggerValue); DoMethod(horiz, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, iconCon, 3, MUIM_Set, ICA_ScrollToHoriz, MUIV_TriggerValue); SetAttrs(win, MUIA_Window_Open, TRUE, TAG_DONE); while(running) { inputResult=DoMethod(app, MUIM_Application_Input, &signals); switch(inputResult) { case MUIV_Application_ReturnID_Quit: running=FALSE; break; case 2: running=FALSE; break; default: { // a menuitem was selected... struct MinList *subjects=NULL; Object *member, *ostate; Tag activeSubjectsTag; struct TagItem args[2]; if(inputResult & DOC_DESKTOPOP) { args[0].ti_Tag=DDO_Target; args[0].ti_Data=iconCon; args[1].ti_Tag=TAG_END; args[1].ti_Data=0; DoDesktopOperation(inputResult, args); } else if(inputResult & DOC_ICONOP) { GetAttr(AICA_SelectedIcons, iconCon, &subjects); ostate=subjects->mlh_Head; while((member=NextObject(&ostate))) { args[0].ti_Tag=DDO_Target; args[0].ti_Data=member; args[1].ti_Tag=TAG_END; args[1].ti_Data=0; DoDesktopOperation(inputResult, args); } } else if(inputResult & DOC_WINDOWOP) { GetAttr(DA_ActiveWindow, iconCon, &subjects); args[0].ti_Tag=DDO_Target; args[0].ti_Data=subjects; args[1].ti_Tag=TAG_END; args[1].ti_Data=0; DoDesktopOperation(inputResult, args); } } } if(running && signals) Wait(signals); } SetAttrs(win, MUIA_Window_Open, FALSE, TAG_DONE); DisposeObject(app); } else kprintf("could not create app\n"); CloseLibrary(DesktopBase); CloseLibrary(MUIMasterBase); return 0; }
int AttachGalley(OBJECT hd, OBJECT *inners, OBJECT *suspend_pt) { OBJECT hd_index; /* the index of hd in the enclosing galley */ OBJECT hd_inners; /* inner galleys of hd, if unsized */ OBJECT dest; /* the target @Galley hd empties into */ OBJECT dest_index; /* the index of dest */ OBJECT target; /* the target indefinite containing dest */ OBJECT target_index; /* the index of target */ OBJECT target_galley; /* the body of target, made into a galley */ OBJECT tg_inners; /* inner galleys of target_galley */ BOOLEAN need_precedes = FALSE;/* true if destination lies before galley */ OBJECT recs; /* list of recursive definite objects */ OBJECT link, y = nilobj; /* for scanning through the components of hd */ CONSTRAINT c; /* temporary variable holding a constraint */ OBJECT env, n1, tmp, zlink, z, sym; /* placeholders and temporaries */ BOOLEAN was_sized; /* true if sized(hd) initially */ int dim; /* the galley direction */ FULL_LENGTH perp_back, perp_fwd; OBJECT why, junk; debug2(DGA, D, "[ AttachGalley(Galley %s into %s)", SymName(actual(hd)), SymName(whereto(hd))); ifdebug(DGA, DD, DebugGalley(hd, nilobj, 4)); assert( Up(hd) != hd, "AttachGalley: no index!" ); Parent(hd_index, Up(hd)); assert( type(hd_index) == UNATTACHED, "AttachGalley: not UNATTACHED!" ); hd_inners = tg_inners = nilobj; was_sized = sized(hd); dim = gall_dir(hd); for(;;) { /*************************************************************************/ /* */ /* Search for a destination for hd. If hd is unsized, search for */ /* inner galleys preceding it first of all, then for receptive objects */ /* following it, possibly in inner galleys. If no luck, exit. */ /* If hd is sized, search only for receptive objects in the current */ /* galley below the current spot, and fail if cannot find any. */ /* */ /*************************************************************************/ sym = whereto(hd); if( sized(hd) ) { /* sized galley case: search on from current spot */ target_index = SearchGalley(Up(hd_index), sym, TRUE, FALSE, TRUE, TRUE); if( target_index == nilobj ) { /* search failed to find any new target, so kill the galley */ for( link = Down(hd); link != hd; link = NextDown(link) ) { Child(y, link); if( type(y) == SPLIT ) Child(y, DownDim(y, dim)); if( is_definite(type(y)) ) break; } if( link != hd ) Error(19, 1, "galley %s deleted from here (no target)", WARN, &fpos(y), SymName(actual(hd))); if( hd_inners != nilobj ) DisposeObject(hd_inners), hd_inners=nilobj; if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners=nilobj; KillGalley(hd, FALSE); *inners = nilobj; debug0(DGA, D, "] AttachGalley returning ATTACH_KILLED"); return ATTACH_KILLED; } else if( actual(actual(target_index)) == InputSym ) { /* search found input object, so suspend on that */ DeleteNode(hd_index); Link(target_index, hd); *inners = nilobj; debug0(DGA, D, "] AttachGalley returning ATTACH_INPUT"); return ATTACH_INPUT; } } else /* unsized galley, either backwards or normal */ { if( foll_or_prec(hd) == GALL_PREC ) { target_index= SearchGalley(Up(hd_index), sym, FALSE, TRUE,TRUE,FALSE); need_precedes = FALSE; } else { target_index = SearchGalley(Up(hd_index), sym, FALSE,TRUE,FALSE,FALSE); need_precedes = (target_index != nilobj); if( target_index == nilobj ) target_index = SearchGalley(Up(hd_index), sym, TRUE,TRUE,TRUE,FALSE); } /* if no luck, exit without error */ if( target_index == nilobj ) { *inners = nilobj; debug0(DGA, D, "] AttachGalley returning ATTACH_NOTARGET"); return ATTACH_NOTARGET; } } assert( type(target_index) == RECEPTIVE, "AttachGalley: target_index!" ); target = actual(target_index); assert( type(target) == CLOSURE, "AttachGalley: target!" ); /* set target_galley to the expanded value of target */ debug1(DYY, D, "[ EnterErrorBlock(FALSE) (expanding target %s)", SymName(actual(target))); EnterErrorBlock(FALSE); New(target_galley, HEAD); force_gall(target_galley) = FALSE; enclose_obj(target_galley) = limiter(target_galley) = nilobj; ClearHeaders(target_galley); opt_components(target_galley) = opt_constraints(target_galley) = nilobj; gall_dir(target_galley) = external_hor(target) ? COLM : ROWM; FposCopy(fpos(target_galley), fpos(target)); actual(target_galley) = actual(target); whereto(target_galley) = ready_galls(target_galley) = nilobj; foll_or_prec(target_galley) = GALL_FOLL; must_expand(target_galley) = FALSE; sized(target_galley) = FALSE; /* get perpendicular constraint (none if horizontal galley) */ if( dim == ROWM ) { Constrained(target, &c, 1-dim, &junk); if( !constrained(c) ) Error(19, 2, "receptive symbol %s has unconstrained width", FATAL, &fpos(target), SymName(actual(target))); debug2(DSC, DD, "Constrained( %s, 1-dim ) = %s", EchoObject(target), EchoConstraint(&c)); if( !FitsConstraint(0, 0, c) ) { debug0(DGA, D, " reject: target_galley horizontal constraint is -1"); y = nilobj; goto REJECT; } } else /* actually unused */ SetConstraint(c, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); debug1(DGA, DDD, " expanding %s", EchoObject(target)); tmp = CopyObject(target, no_fpos); Link(target_galley, tmp); env = DetachEnv(tmp); debug4(DGM, D, " external_ver(%s) = %s, external_hor(%s) = %s", SymName(actual(target)), bool(external_ver(target)), SymName(actual(target)), bool(external_hor(target))); SizeGalley(target_galley, env, external_ver(target) || external_hor(target), threaded(target), non_blocking(target_index), trigger_externs(target_index), &save_style(target), &c, whereto(hd), &dest_index, &recs, &tg_inners, enclose_obj(hd) != nilobj ? CopyObject(enclose_obj(hd), no_fpos):nilobj); debug1(DGA, DD, " SizeGalley tg_inners: %s", DebugInnersNames(tg_inners)); if( recs != nilobj ) ExpandRecursives(recs); dest = actual(dest_index); if( underline(dest) == UNDER_UNDEF ) underline(dest) = UNDER_OFF; /* verify that hd satisfies any horizontal constraint on dest */ if( dim == ROWM ) { debug1(DGA, DDD, " checking hor fit of hd in %s",SymName(actual(dest))); Constrained(dest, &c, 1-dim, &junk); debug3(DSC, DD, "Constrained( %s, %s ) = %s", EchoObject(dest), dimen(1-dim), EchoConstraint(&c)); assert( constrained(c), "AttachGalley: dest unconstrained!" ); if( !FitsConstraint(0, 0, c) ) { debug0(DGA, D, " reject: hd horizontal constraint is -1"); y = nilobj; goto REJECT; } } /* manifest and size the galley if not done yet */ if( !sized(hd) ) { debug2(DYY, D, "[ EnterErrorBlock(TRUE) (sizing galley %s into %s)", SymName(actual(hd)), SymName(whereto(hd))); EnterErrorBlock(TRUE); n1 = nilobj; Child(y, Down(hd)); env = DetachEnv(y); /*** threaded() only defined in ROWM case SizeGalley(hd, env, TRUE, threaded(dest), non_blocking(target_index), TRUE, &save_style(dest), &c, nilobj, &n1, &recs, &hd_inners); *** */ SizeGalley(hd, env, TRUE, dim == ROWM ? threaded(dest) : FALSE, non_blocking(target_index), TRUE, &save_style(dest), &c, nilobj, &n1, &recs, &hd_inners, nilobj); debug1(DGA,DD," SizeGalley hd_inners: %s", DebugInnersNames(hd_inners)); if( recs != nilobj ) ExpandRecursives(recs); if( need_precedes ) /* need an ordering constraint */ { OBJECT index1, index2; New(index1, PRECEDES); New(index2, FOLLOWS); blocked(index2) = FALSE; tmp = MakeWord(WORD, STR_EMPTY, no_fpos); Link(index1, tmp); Link(index2, tmp); Link(Up(hd_index), index1); Link(Down(hd), index2); debug0(DGA, D, " inserting PRECEDES and FOLLOWS"); } LeaveErrorBlock(TRUE); debug0(DYY, D, "] LeaveErrorBlock(TRUE) (finished sizing galley)"); } if( dim == ROWM ) { if( !FitsConstraint(back(hd, 1-dim), fwd(hd, 1-dim), c) ) { debug3(DGA, D, " reject: hd %s,%s does not fit target_galley %s", EchoLength(back(hd, 1-dim)), EchoLength(fwd(hd, 1-dim)), EchoConstraint(&c)); Error(19, 3, "too little horizontal space for galley %s at %s", WARN, &fpos(hd), SymName(actual(hd)), SymName(actual(dest))); goto REJECT; } } /* check status of first component of hd */ debug0(DGA, DDD, " now ready to attach; hd ="); ifdebug(DGA, DDD, DebugObject(hd)); for( link = Down(hd); link != hd; link = NextDown(link) ) { Child(y, link); debug1(DGA, DDD, " examining %s", EchoIndex(y)); if( type(y) == SPLIT ) Child(y, DownDim(y, dim)); switch( type(y) ) { case EXPAND_IND: case SCALE_IND: case COVER_IND: case GALL_PREC: case GALL_FOLL: case GALL_FOLL_OR_PREC: case GALL_TARG: case CROSS_PREC: case CROSS_FOLL: case CROSS_FOLL_OR_PREC: case CROSS_TARG: case PAGE_LABEL_IND: break; case PRECEDES: case UNATTACHED: if( was_sized ) { /* SizeGalley was not called, so hd_inners was not set by it */ if( hd_inners == nilobj ) New(hd_inners, ACAT); Link(hd_inners, y); } break; case RECEPTIVE: goto SUSPEND; case RECEIVING: goto SUSPEND; case FOLLOWS: Child(tmp, Down(y)); if( Up(tmp) == LastUp(tmp) ) { link = pred(link, CHILD); debug0(DGA, DD, " disposing FOLLOWS"); DisposeChild(NextDown(link)); break; } Parent(tmp, Up(tmp)); assert(type(tmp) == PRECEDES, "Attach: PRECEDES!"); switch( CheckComponentOrder(tmp, target_index) ) { case CLEAR: DeleteNode(tmp); link = pred(link, CHILD); DisposeChild(NextDown(link)); break; case PROMOTE: break; case BLOCK: debug0(DGA, DD, "CheckContraint: BLOCK"); goto SUSPEND; case CLOSE: debug0(DGA, D, " reject: CheckContraint"); goto REJECT; } break; case GAP_OBJ: underline(y) = underline(dest); if( !join(gap(y)) ) seen_nojoin(hd) = TRUE; break; case BEGIN_HEADER: case END_HEADER: case SET_HEADER: case CLEAR_HEADER: /* do nothing until actually promoted out of here */ underline(y) = underline(dest); break; case CLOSURE: case CROSS: case FORCE_CROSS: case NULL_CLOS: case PAGE_LABEL: underline(y) = underline(dest); break; case WORD: case QWORD: case ONE_COL: case ONE_ROW: case WIDE: case HIGH: case HSHIFT: case VSHIFT: case HMIRROR: case VMIRROR: case HSCALE: case VSCALE: case HCOVER: case VCOVER: case HCONTRACT: case VCONTRACT: case HLIMITED: case VLIMITED: case HEXPAND: case VEXPAND: case START_HVSPAN: case START_HSPAN: case START_VSPAN: case HSPAN: case VSPAN: case ROTATE: case BACKGROUND: case SCALE: case KERN_SHRINK: case INCGRAPHIC: case SINCGRAPHIC: case PLAIN_GRAPHIC: case GRAPHIC: case LINK_SOURCE: case LINK_DEST: case LINK_DEST_NULL: case LINK_URL: case ACAT: case HCAT: case VCAT: case ROW_THR: case COL_THR: underline(y) = underline(dest); if( dim == ROWM ) { /* make sure y is not joined to a target below (vertical only) */ for( zlink = NextDown(link); zlink != hd; zlink = NextDown(zlink) ) { Child(z, zlink); switch( type(z) ) { case RECEPTIVE: if( non_blocking(z) ) { zlink = PrevDown(zlink); DeleteNode(z); } else { y = z; goto SUSPEND; } break; case RECEIVING: if( non_blocking(z) ) { zlink = PrevDown(zlink); while( Down(z) != z ) { Child(tmp, Down(y)); if( opt_components(tmp) != nilobj ) { DisposeObject(opt_components(tmp)); opt_components(tmp) = nilobj; debug3(DOG, D, "AttachGalley(%s) de-optimizing %s %s", SymName(actual(hd)), SymName(actual(tmp)), "(join)"); } DetachGalley(tmp); KillGalley(tmp, FALSE); } DeleteNode(z); } else { y = z; goto SUSPEND; } break; case GAP_OBJ: if( !join(gap(z)) ) zlink = PrevDown(hd); break; default: break; } } /* if HCAT, try vertical hyphenation (vertical galleys only) */ if( type(y) == HCAT ) VerticalHyphenate(y); } /* check availability of parallel space for the first component */ why = nilobj; Constrained(dest, &c, dim, &why); debug3(DGF, DD, " dest parallel Constrained(%s, %s) = %s", EchoObject(dest), dimen(dim), EchoConstraint(&c)); if( !FitsConstraint(back(y, dim), fwd(y, dim), c) ) { BOOLEAN scaled; /* if forcing galley doesn't fit, try scaling first component */ scaled = FALSE; if( force_gall(hd) && size(y, dim) > 0 ) { int scale_factor; scale_factor = ScaleToConstraint(back(y,dim), fwd(y,dim), &c); if( scale_factor > 0.5 * SF ) { char num1[20], num2[20]; sprintf(num1, "%.1fc", (float) size(y, dim) / CM); sprintf(num2, "%.1fc", (float) bfc(c) / CM); if( dim == ROWM ) Error(19, 4, "%s object too high for %s space; %s inserted", WARN, &fpos(y), num1, num2, KW_SCALE); else Error(19, 5, "%s object too wide for %s space; %s inserted", WARN, &fpos(y), num1, num2, KW_SCALE); y = InterposeScale(y, scale_factor, dim); scaled = TRUE; } } /* otherwise we must reject, and warn the user */ if( !scaled ) { char num1[20], num2[20]; debug3(DGA, D, " reject: vsize %s,%s in %s; y=", EchoLength(back(y, dim)), EchoLength(fwd(y, dim)), EchoConstraint(&c)); ifdebug(DGA, D, DebugObject(y)); if( size(y, dim) > 0 ) { sprintf(num1, "%.1fc", (float) size(y, dim) / CM); sprintf(num2, "%.1fc", (float) bfc(c) / CM); if( dim == ROWM ) Error(19, 12, "%s object too high for %s space; will try elsewhere", WARN, &fpos(y), num1, num2); else Error(19, 13, "%s object too wide for %s space; will try elsewhere", WARN, &fpos(y), num1, num2); } goto REJECT; } } /* check availability of perpendicular space for first component */ if( dim == ROWM ) { perp_back = back(hd, 1-dim); perp_fwd = fwd(hd, 1-dim); } else { perp_back = back(y, 1-dim); perp_fwd = fwd(y, 1-dim); } Constrained(dest, &c, 1-dim, &junk); debug3(DGF, DD, " dest perpendicular Constrained(%s, %s) = %s", EchoObject(dest), dimen(1-dim), EchoConstraint(&c)); if( !FitsConstraint(perp_back, perp_fwd, c) ) { BOOLEAN scaled; /* if forcing galley doesn't fit, try scaling first component */ scaled = FALSE; if( force_gall(hd) && perp_back + perp_fwd > 0 ) { int scale_factor; scale_factor = ScaleToConstraint(perp_back, perp_fwd, &c); if( scale_factor > 0.5 * SF ) { char num1[20], num2[20]; sprintf(num1, "%.1fc", (float) (perp_back + perp_fwd) / CM); sprintf(num2, "%.1fc", (float) bfc(c) / CM); if( 1-dim == ROWM ) Error(19, 6, "%s object too high for %s space; %s inserted", WARN, &fpos(y), num1, num2, KW_SCALE); else Error(19, 7, "%s object too wide for %s space; %s inserted", WARN, &fpos(y), num1, num2, KW_SCALE); y = InterposeScale(y, scale_factor, 1-dim); scaled = TRUE; } } /* otherwise we must reject, and warn the user */ if( !scaled ) { debug3(DGA, D, " reject: vsize %s,%s in %s; y=", EchoLength(perp_back), EchoLength(perp_fwd), EchoConstraint(&c)); ifdebug(DGA, D, DebugObject(y)); goto REJECT; } } /* dest seems OK, so perform its size adjustments */ debug0(DSA, D, "calling AdjustSize from AttachGalley (a)"); AdjustSize(dest, back(y, dim), fwd(y, dim), dim); debug0(DSA, D, "calling AdjustSize from AttachGalley (b)"); AdjustSize(dest, perp_back, perp_fwd, 1-dim); /* now check parallel space for target_galley in target */ Constrained(target, &c, dim, &why); debug3(DGF, DD, " target parallel Constrained(%s, %s) = %s", EchoObject(target), dimen(dim), EchoConstraint(&c)); Child(z, LastDown(target_galley)); /* works in all cases? */ assert( !is_index(type(z)), "AttachGalley: is_index(z)!" ); assert( back(z, dim)>=0 && fwd(z, dim)>=0, "AttachGalley: z size!" ); if( !FitsConstraint(back(z, dim), fwd(z, dim), c) ) { BOOLEAN scaled; debug2(DGA, D, " why = %d %s", (int) why, EchoObject(why)); debug2(DGA, D, " limiter = %d %s", (int) limiter(hd), EchoObject(limiter(hd))); /* if forcing galley doesn't fit, try scaling z */ scaled = FALSE; if( force_gall(hd) && size(z, dim) > 0 && limiter(hd) != why ) { int scale_factor; scale_factor = ScaleToConstraint(back(z,dim), fwd(z,dim), &c); if( scale_factor > 0.5 * SF ) { char num1[20], num2[20]; sprintf(num1, "%.1fc", (float) size(z, dim) / CM); sprintf(num2, "%.1fc", (float) bfc(c) / CM); if( dim == ROWM ) Error(19, 8, "%s object too high for %s space; %s inserted", WARN, &fpos(y), num1, num2, KW_SCALE); else Error(19, 9, "%s object too wide for %s space; %s inserted", WARN, &fpos(y), num1, num2, KW_SCALE); z = InterposeWideOrHigh(z, dim); z = InterposeScale(z, scale_factor, dim); scaled = TRUE; } } if( !scaled ) { char num1[20], num2[20]; limiter(hd) = why; debug3(DGA, D, " set limiter(%s) = %d %s", SymName(actual(hd)), (int) limiter(hd), EchoObject(limiter(hd))); debug3(DGA, D, " reject: size was %s,%s in %s; y =", EchoLength(back(z, dim)), EchoLength(fwd(z, dim)), EchoConstraint(&c)); ifdebug(DGA, D, DebugObject(y)); if( size(z, dim) > 0 ) { sprintf(num1, "%.1fc", (float) size(z, dim) / CM); sprintf(num2, "%.1fc", (float) bfc(c) / CM); if( dim == ROWM ) Error(19, 14, "%s object too high for %s space; will try elsewhere", WARN, &fpos(y), num1, num2); else Error(19, 15, "%s object too wide for %s space; will try elsewhere", WARN, &fpos(y), num1, num2); } goto REJECT; } } limiter(hd) = why; debug3(DGA, D, " set limiter(%s) = %d %s", SymName(actual(hd)), (int) limiter(hd), EchoObject(limiter(hd))); /* now check perpendicular space for target_galley in target */ Constrained(target, &c, 1-dim, &junk); debug3(DGF, DD, " target perpendicular Constrained(%s, %s) = %s", EchoObject(target), dimen(1-dim), EchoConstraint(&c)); Child(z, LastDown(target_galley)); /* works in all cases? */ assert( !is_index(type(z)), "AttachGalley: is_index(z)!" ); assert( back(z, 1-dim)>=0 && fwd(z, 1-dim)>=0, "AttachGalley: z size (perpendicular)!" ); if( !FitsConstraint(back(z, 1-dim), fwd(z, 1-dim), c) ) { BOOLEAN scaled; /* if forcing galley doesn't fit, try scaling z */ scaled = FALSE; if( force_gall(hd) && size(z, 1-dim) > 0 ) { int scale_factor; scale_factor = ScaleToConstraint(back(z,1-dim), fwd(z,1-dim), &c); if( scale_factor > 0.5 * SF ) { char num1[20], num2[20]; sprintf(num1, "%.1fc", (float) size(z, 1-dim) / CM); sprintf(num2, "%.1fc", (float) bfc(c) / CM); if( 1-dim == ROWM ) Error(19, 10, "%s object too high for %s space; %s inserted", WARN, &fpos(y), num1, num2, KW_SCALE); else Error(19, 11, "%s object too wide for %s space; %s inserted", WARN, &fpos(y), num1, num2, KW_SCALE); z = InterposeWideOrHigh(z, 1-dim); z = InterposeScale(z, scale_factor, 1-dim); scaled = TRUE; } } if( !scaled ) { debug3(DGA, D, " reject: size was %s,%s in %s; y =", EchoLength(back(z, 1-dim)), EchoLength(fwd(z, 1-dim)), EchoConstraint(&c)); ifdebug(DGA, D, DebugObject(y)); goto REJECT; } } /* target seems OK, so adjust sizes and accept */ if( external_hor(target) ) { /* don't adjust any sizes, none to adjust */ debug0(DSA, D, "not calling AdjustSize from AttachGalley (c)"); } else if( external_ver(target) ) { /* adjust perp size only, to galley size */ debug0(DSA, D, "calling AdjustSize from AttachGalley (d)"); AdjustSize(target, back(target_galley, 1-dim), fwd(target_galley, 1-dim), 1-dim); } else { /* adjust both directions, using z (last component) */ Child(z, LastDown(target_galley)); debug0(DSA, D, "AttachGalley AdjustSize using z ="); ifdebug(DSA, D, DebugObject(z)); debug0(DSA, D, "calling AdjustSize from AttachGalley (e)"); AdjustSize(target, back(z, dim), fwd(z, dim), dim); debug0(DSA, D, "calling AdjustSize from AttachGalley (f)"); AdjustSize(target, back(z, 1-dim), fwd(z, 1-dim), 1-dim); } goto ACCEPT; default: assert1(FALSE, "AttachGalley:", Image(type(y))); break; } /* end switch */ } /* end for */ /* null galley: promote whole galley without expanding the target */ debug0(DGA, D, " null galley"); if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj; DisposeObject(target_galley); LeaveErrorBlock(FALSE); debug0(DYY, D, "] LeaveErrorBlock(FALSE) (null galley)"); /* kill off any null objects within the galley, then transfer it */ /* don't use Promote() since it does extra unwanted things here */ for( link = Down(hd); link != hd; link = NextDown(link) ) { Child(y, link); switch( type(y) ) { case GAP_OBJ: case CLOSURE: case CROSS: case FORCE_CROSS: case NULL_CLOS: case PAGE_LABEL: link = PrevDown(link); debug1(DGA, D, " null galley, disposing %s", Image(type(y))); DisposeChild(NextDown(link)); break; default: break; } } TransferLinks(NextDown(hd), hd, Up(target_index)); /* attach hd temporarily to target_index */ MoveLink(Up(hd), target_index, PARENT); assert( type(hd_index) == UNATTACHED, "AttachGalley: type(hd_index)!" ); DeleteNode(hd_index); /* return; only hd_inners needs to be flushed now */ *inners = hd_inners; debug0(DGA, D, "] AttachGalley returning ATTACH_NULL"); return ATTACH_NULL; REJECT: /* reject first component */ /* debug1(DGA, D, " reject %s", EchoObject(y)); */ debug0(DGA, D, " reject first component"); LeaveErrorBlock(TRUE); debug0(DYY, D, "] LeaveErrorBlock(TRUE) (REJECT)"); if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj; DisposeObject(target_galley); if( foll_or_prec(hd) == GALL_PREC && !sized(hd) ) { /* move to just before the failed target */ MoveLink(Up(hd_index), Up(target_index), PARENT); } else { /* move to just after the failed target */ MoveLink(Up(hd_index), NextDown(Up(target_index)), PARENT); } continue; SUSPEND: /* suspend at first component */ debug1(DGA, D, " suspend %s", EchoIndex(y)); blocked(y) = TRUE; LeaveErrorBlock(FALSE); debug0(DYY, D, "] LeaveErrorBlock(FALSE) (SUSPEND)"); if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj; DisposeObject(target_galley); MoveLink(Up(hd_index), Up(target_index), PARENT); if( was_sized ) { /* nothing new to flush if suspending and already sized */ if( hd_inners != nilobj ) DisposeObject(hd_inners), hd_inners=nilobj; *inners = nilobj; } else { /* flush newly discovered inners if not sized before */ *inners = hd_inners; } debug0(DGA, D, "] AttachGalley returning ATTACH_SUSPEND"); *suspend_pt = y; return ATTACH_SUSPEND; ACCEPT: /* accept first component; now committed to the attach */ debug3(DGA, D, " accept %s %s %s", Image(type(y)), EchoObject(y), EchoFilePos(&fpos(y))); LeaveErrorBlock(TRUE); debug0(DYY, D, "] LeaveErrorBlock(TRUE) (ACCEPT)"); /* attach hd to dest */ MoveLink(Up(hd), dest_index, PARENT); assert( type(hd_index) == UNATTACHED, "AttachGalley: type(hd_index)!" ); DeleteNode(hd_index); /* move first component of hd into dest */ /* nb Interpose must be done after all AdjustSize calls */ if( dim == ROWM && !external_ver(dest) ) Interpose(dest, VCAT, hd, y); else if( dim == COLM && !external_hor(dest) ) { Interpose(dest, ACAT, y, y); Parent(junk, Up(dest)); assert( type(junk) == ACAT, "AttachGalley: type(junk) != ACAT!" ); StyleCopy(save_style(junk), save_style(dest)); adjust_cat(junk) = padjust(save_style(junk)); } debug1(DGS, D, "calling Promote(hd, %s) from AttachGalley/ACCEPT", link == hd ? "hd" : "NextDown(link)"); Promote(hd, link == hd ? hd : NextDown(link), dest_index, TRUE); /* move target_galley into target */ /* nb Interpose must be done after all AdjustSize calls */ if( !(external_ver(target) || external_hor(target)) ) { Child(z, LastDown(target_galley)); Interpose(target, VCAT, z, z); } debug0(DGS, D, "calling Promote(target_galley) from AttachGalley/ACCEPT"); Promote(target_galley, target_galley, target_index, TRUE); DeleteNode(target_galley); assert(Down(target_index)==target_index, "AttachGalley: target_ind"); if( blocked(target_index) ) blocked(dest_index) = TRUE; DeleteNode(target_index); /* return; both tg_inners and hd_inners need to be flushed now; */ /* if was_sized, hd_inners contains the inners of the first component; */ /* otherwise it contains the inners of all components, from SizeGalley */ if( tg_inners == nilobj ) *inners = hd_inners; else if( hd_inners == nilobj ) *inners = tg_inners; else { TransferLinks(Down(hd_inners), hd_inners, tg_inners); DeleteNode(hd_inners); *inners = tg_inners; } debug0(DGA, D, "] AttachGalley returning ATTACH_ACCEPT"); ifdebug(DGA, D, if( dim == COLM && !external_hor(dest) ) { OBJECT z; Parent(z, Up(dest)); debug2(DGA, D, " COLM dest_encl on exit = %s %s", Image(type(z)), EchoObject(z)); } ) return ATTACH_ACCEPT; } /* end for */
/* The following cases apply: Make black transparent Make white transparent Make any color transparent Make background transparent */ PERROR OpenGUI(FRAME *frame, struct Objects *o, struct Values *v, struct PPTBase *PPTBase) { struct Library *BGUIBase = PPTBase->lb_BGUI; struct Screen *scr = PPTBase->g->maindisp->scr; struct Library *ColorWheelBase = o->ColorWheelBase; struct GfxBase *GfxBase = PPTBase->lb_Gfx; struct IntuitionBase *IntuitionBase = PPTBase->lb_Intuition; BOOL V39 = FALSE; struct ColorWheelRGB rgb; struct ColorWheelHSB hsb; sprintf(o->wtitle, MYNAME ": %s", frame->name ); if( PPTBase->lb_Gfx->LibNode.lib_Version >= 39 ) { int i; V39 = TRUE; rgb.cw_Red = 0; rgb.cw_Green = 0; rgb.cw_Blue = 0; ConvertRGBToHSB( &rgb, &hsb ); for( i = 0; i < GRADCOLORS; i++ ) { hsb.cw_Brightness = (ULONG)0xffffffff - (((ULONG)0xffffffff / GRADCOLORS ) * i ); ConvertHSBToRGB( &hsb, &rgb ); if( -1 == (o->pens[i] = ObtainBestPen( scr->ViewPort.ColorMap, rgb.cw_Red, rgb.cw_Green, rgb.cw_Blue, TAG_DONE ) ) ) { break; } } o->pens[i] = ~0; o->numpens = i; o->Gradient = ExternalObject, GA_ID, GID_GRADIENTSLIDER, EXT_MinWidth, 10, EXT_MinHeight, 10, EXT_ClassID, "gradientslider.gadget", EXT_NoRebuild, TRUE, GRAD_PenArray, o->pens, PGA_Freedom, LORIENT_VERT, EndObject; if( o->Gradient ) GetAttr( EXT_Object, o->Gradient, (ULONG *) &o->RealGradient ); } o->Win = WindowObject, WINDOW_Screen, scr, WINDOW_Title, o->wtitle, WINDOW_ScreenTitle, "Transparency: Click on the image to choose a color", v->window.Height ? TAG_IGNORE : TAG_SKIP, 1, WINDOW_Bounds, &v->window, WINDOW_ScaleWidth, 30, WINDOW_NoBufferRP, TRUE, WINDOW_MenuStrip, mymenus, // WINDOW_HelpFile, "Docs/effects.guide", // WINDOW_HelpNode, "Transparency", // WINDOW_HelpText, infoblurb, WINDOW_CloseOnEsc, TRUE, WINDOW_MasterGroup, VGroupObject, Spacing(4), HOffset(6), VOffset(4), StartMember, HGroupObject, Spacing(6), StartMember, VGroupObject, Spacing(4), StartMember, InfoObject, INFO_TextFormat, ISEQ_C "Please, do select\n" "which color should be\n" "transparent:", INFO_MinLines, 3, ButtonFrame, FRM_Flags, FRF_RECESSED, EndObject, LGO_NoAlign, TRUE, EndMember, VarSpace(25), StartMember, VGroupObject, StartMember, HGroupObject, Spacing(3), StartMember, o->Red = SliderObject, GA_ID, GID_RED, Label("Red"), Place(PLACE_LEFT), SLIDER_Min, 0, SLIDER_Max, 255, SLIDER_Level, v->r, EndObject, EndMember, StartMember, o->RedI = StringObject, GA_ID, GID_REDI, STRINGA_MinCharsVisible,4, STRINGA_MaxChars, 3, STRINGA_IntegerMin, 0, STRINGA_IntegerMax, 255, STRINGA_LongVal, v->r, EndObject, Weight(1), EndMember, EndObject, FixMinHeight, EndMember, StartMember, HGroupObject, Spacing(3), StartMember, o->Green = SliderObject, GA_ID, GID_GREEN, Label("Green"), Place(PLACE_LEFT), SLIDER_Min, 0, SLIDER_Max, 255, SLIDER_Level, v->g, EndObject, EndMember, StartMember, o->GreenI = StringObject, GA_ID, GID_GREENI, STRINGA_MinCharsVisible,4, STRINGA_MaxChars, 3, STRINGA_IntegerMin, 0, STRINGA_IntegerMax, 255, STRINGA_LongVal, v->g, EndObject, Weight(1), EndMember, EndObject, FixMinHeight, EndMember, StartMember, HGroupObject, Spacing(3), StartMember, o->Blue = SliderObject, GA_ID, GID_BLUE, Label("Blue"), Place(PLACE_LEFT), SLIDER_Min, 0, SLIDER_Max, 255, SLIDER_Level, v->b, EndObject, EndMember, StartMember, o->BlueI = StringObject, GA_ID, GID_BLUEI, STRINGA_MinCharsVisible,4, STRINGA_MaxChars, 3, STRINGA_IntegerMin, 0, STRINGA_IntegerMax, 255, STRINGA_LongVal, v->b, EndObject, Weight(1), EndMember, EndObject, FixMinHeight, EndMember, EndObject, EndMember, VarSpace(25), EndObject, LGO_NoAlign, TRUE, EndMember, (V39) ? TAG_IGNORE : TAG_SKIP, 2, StartMember, o->Wheel = ExternalObject, EXT_MinWidth, 30, EXT_MinHeight, 30, EXT_ClassID, "colorwheel.gadget", WHEEL_Screen, scr, /* ** Pass a pointer to the "real" gradient slider ** here. **/ WHEEL_GradientSlider, o->RealGradient, WHEEL_Red, v->r * 0x01010101, WHEEL_Green, v->g * 0x01010101, WHEEL_Blue, v->b * 0x01010101, GA_FollowMouse, TRUE, GA_ID, GID_WHEEL, /* ** These attributes of the colorwheel are ** tracked and reset to the object after ** it has been rebuild. This way the current ** colorwheel internals will not be lost ** after the object is re-build. **/ EXT_TrackAttr, WHEEL_Red, EXT_TrackAttr, WHEEL_Green, EXT_TrackAttr, WHEEL_Blue, EXT_TrackAttr, WHEEL_Hue, EXT_TrackAttr, WHEEL_Saturation, EXT_TrackAttr, WHEEL_Brightness, EndObject, EndMember, (V39) ? TAG_IGNORE : TAG_SKIP, 3, StartMember, o->Gradient, FixWidth(20), EndMember, EndObject, LGO_NoAlign, TRUE, EndMember, StartMember, HGroupObject, StartMember, o->Trans = SliderObject, GA_ID, GID_TRANSPARENCY, Label("Transparency:"), Place(PLACE_LEFT), SLIDER_Min, 0, SLIDER_Max, 255, SLIDER_Level, v->transp, EndObject, EndMember, StartMember, o->TransI = StringObject, GA_ID, GID_TRANSPARENCYI, STRINGA_MinCharsVisible,4, STRINGA_MaxChars, 3, STRINGA_IntegerMin, 0, STRINGA_IntegerMax, 255, STRINGA_LongVal, v->transp, EndObject, Weight(1), EndMember, EndObject, FixMinHeight, EndMember, StartMember, HGroupObject, NormalSpacing, StartMember, o->All = CheckBoxObject, GA_ID, GID_ALL, Label("All colors?"), GA_Selected, (v->mode == MODE_ALL) ? TRUE : FALSE, EndObject, Weight(1), EndMember, StartMember, o->Tolerance = SliderObject, GA_ID, GID_TOLERANCE, Label("Tolerance:"), Place(PLACE_LEFT), SLIDER_Min, 0, SLIDER_Max, 255, SLIDER_Level, v->tolerance, EndObject, EndMember, StartMember, o->ToleranceI = StringObject, GA_ID, GID_TOLERANCEI, STRINGA_MinCharsVisible, 4, STRINGA_MaxChars, 3, STRINGA_IntegerMin, 0, STRINGA_IntegerMax, 255, STRINGA_LongVal, v->tolerance, EndObject, Weight(1), EndMember, EndObject, FixMinHeight, EndMember, StartMember, HorizSeparator, EndMember, StartMember, HGroupObject, StartMember, ButtonObject, GA_ID, GID_OK, Label("OK"), Place(PLACE_IN), EndObject, EndMember, VarSpace(DEFAULT_WEIGHT/2), StartMember, ButtonObject, GA_ID, GID_CANCEL, Label("Cancel"), Place(PLACE_IN), EndObject, EndMember, EndObject, FixMinHeight, EndMember, EndObject, EndObject; if( o->Win ) { /* * Attach the gadgets unto each other */ AddMap( o->Trans, o->TransI, dpcol_sl2int ); AddMap( o->TransI,o->Trans, dpcol_int2sl ); AddMap( o->Red, o->RedI, dpcol_sl2int ); AddMap( o->RedI,o->Red, dpcol_int2sl ); AddMap( o->Green, o->GreenI, dpcol_sl2int ); AddMap( o->GreenI,o->Green, dpcol_int2sl ); AddMap( o->Blue, o->BlueI, dpcol_sl2int ); AddMap( o->BlueI,o->Blue, dpcol_int2sl ); AddMap( o->Tolerance, o->ToleranceI, dpcol_sl2int ); AddMap( o->ToleranceI,o->Tolerance, dpcol_int2sl ); AddCondit( o->All, o->Red, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); AddCondit( o->All, o->RedI, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); AddCondit( o->All, o->Green, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); AddCondit( o->All, o->GreenI, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); AddCondit( o->All, o->Blue, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); AddCondit( o->All, o->BlueI, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); AddCondit( o->All, o->ToleranceI, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); AddCondit( o->All, o->Tolerance, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); if(V39) { AddCondit( o->All, o->Wheel, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); AddCondit( o->All, o->Gradient, GA_Selected, FALSE, GA_Disabled, FALSE, GA_Disabled, TRUE ); } if( o->win = WindowOpen(o->Win) ) { /* This sets the other gadgets disabled or enabled */ SetGadgetAttrs( (struct Gadget *)o->All, o->win, NULL, GA_Selected, (v->mode == MODE_ALL) ? TRUE : FALSE, TAG_DONE ); } else { DisposeObject(o->Win); } } return (BOOL)(o->win ? PERR_OK : PERR_WINDOWOPEN); }
void main(int argc, char *argv[]) { struct gtbApplication *appl=NULL; struct Window *Wnd; struct Gadget *GList=NULL; Object *prev; unless(appl=gtbNewApplication(TAG_DONE)) Leave("Can't create application"); unless(Scrn=NewObject(appl->ga_ScrClass,NULL, SCRN_LikeWorkbench,TRUE, SCRN_PubName,APPPUBNAME, SCRN_Private,FALSE, SCRN_Title,APPPUBNAME, TAG_DONE)) Leave("Can't create screen"); unless(Cdity=NewObject(appl->ga_CxClass,NULL, COMM_Name,APPNAME, COMM_Title,APPTITLE, COMM_Description,APPDESCRIPTION, COMM_Unique,TRUE, COMM_Notify,TRUE, COMM_ShowHide,TRUE, COMM_Handler,(ULONG)CdityHandler, COMM_AddHotKeyStr,"control t",COMM_AddHotKeyID,1, TAG_DONE)) Leave("Can't create commodity"); unless(CtrlC=NewObject(appl->ga_MsgClass,NULL, MESG_SigBit,SIGBREAKF_CTRL_C, MESG_Handler,(ULONG)CtrlCHandler, TAG_DONE)) Leave("Can't create message handler"); unless(ARexx=NewObject(appl->ga_ARexxClass,NULL, REXX_Name,APPPUBNAME, REXX_Extension,APPEXTENSION, REXX_CommandTable,commands, REXX_Handler,(ULONG)ARexxHandler, TAG_DONE)) Leave("Can't create arexx"); unless(AmigaGuide=NewObject(appl->ga_AGClass,NULL, AGUI_Name,APPGUIDE, AGUI_ScreenObject,Scrn, AGUI_ARexxObject,ARexx, AGUI_Activate,TRUE, AGUI_BaseName,APPNAME, TAG_DONE)) Leave("Can't create amigaguide"); unless(MainWnd=NewObject(appl->ga_WndClass,NULL,WIND_CenterX,600,WIND_CenterY,20,WIND_Width,200,WIND_Height,200, WIND_DragBar,TRUE, WIND_DepthGadget,TRUE, WIND_SizeGadget,TRUE, WIND_CloseGadget,TRUE, WIND_Title,APPTITLE, WIND_ScreenObject,Scrn, WIND_VertScroll,TRUE, WIND_VertTotal,10, WIND_HorizScroll,TRUE, WIND_HorizTotal,10, WIND_HorizVisible,5, WIND_IDCMP,IDCMP_CLOSEWINDOW|IDCMP_GADGETUP, WIND_Handler,(ULONG)WndHandler, WIND_Activate,TRUE, WIND_MaxWidth,-1, WIND_MaxHeight,-1, TAG_DONE)) Leave("Can't create window"); GetAttr(WIND_Window,MainWnd,(ULONG *)&Wnd); unless(prev=(Object *)CreateContext(&GList)) Leave("Can't create context"); unless(prev=gtbCreateGadget(BUTTON_KIND,NULL,NULL, GA_Previous,prev, GA_Left,Wnd->BorderLeft, GA_Top,Wnd->BorderTop, GA_Width,100, GA_Height,20, GA_Text,"Ble", GT_ScreenObj,Scrn, GT_Handler,(ULONG)Gad1Handler, TAG_DONE)) Leave("Can't create gadget 1"); unless(prev=gtbCreateGadget(STRING_KIND,NULL,NULL, GA_Previous,prev, GA_Left,Wnd->BorderLeft, GA_Top,Wnd->BorderTop+30, GA_Width,100, GA_Height,20, GA_Text,"Ble2", GT_ScreenObj,Scrn, TAG_DONE)) Leave("Can't create gadget 2"); unless(prev=gtbCreateGadget(BOOPSI_KIND,NULL,FRBUTTONCLASS, GA_Previous,prev, GA_Left,Wnd->BorderLeft, GA_Top,Wnd->BorderTop+60, GA_Width,100, GA_Height,20, GA_Text,"Ble3", ICA_TARGET,ICTARGET_IDCMP, TAG_DONE)) Leave("Can't create gadget 3"); DoMethod(MainWnd,OM_ADDMEMBER,GList); RefreshGList(GList,Wnd,NULL,-1); GT_RefreshWindow(Wnd,NULL); gtbExecuteRexx(ARexx,argv[1]); while(gtbHandleObject(MainWnd,Cdity,CtrlC,ARexx,AmigaGuide,TAG_DONE)); RemoveGList(Wnd,GList,-1); gtbFreeGadgets(GList); end: if(AmigaGuide) DisposeObject(AmigaGuide); if(ARexx) DisposeObject(ARexx); if(MainWnd) DisposeObject(MainWnd); if(CtrlC) DisposeObject(CtrlC); if(Cdity) DisposeObject(Cdity); if(Scrn) DisposeObject(Scrn); if(appl) gtbDisposeApplication(appl); }
int GetConvArgs( FRAME *frame, struct TagItem *tags, struct PPTBase *xd, struct convargs *cargs ) { Object *Win, *wtgroup, *weights[7][7], *Bias, *Frq, *Name, *Div; ULONG sigmask, sig, rc; int quit = FALSE, res = PERR_OK,i,j; struct Window *win; struct IntuitionBase *IntuitionBase = xd->lb_Intuition; struct ExecBase *SysBase = xd->lb_Sys; struct Library *BGUIBase = xd->lb_BGUI; char *name = "Unknown"; #ifdef DEBUG_MODE PDebug("\tCreating window object\n"); #endif Win = WindowObject, WINDOW_Screen, xd->g->maindisp->scr, WINDOW_Title, frame->nd.ln_Name, WINDOW_Font, xd->g->userprefs->mainfont, WINDOW_ScreenTitle, "Convolute Tool", WINDOW_ScaleWidth, 20, WINDOW_MenuStrip, Menus, TAG_SKIP, (cargs->winpos.Height == 0) ? 1 : 0, WINDOW_Bounds, &(cargs->winpos), WINDOW_NoBufferRP, TRUE, WINDOW_MasterGroup, VGroupObject, Spacing(4), HOffset(6), VOffset(4), StartMember, Name = InfoFixed("Name:","",NULL,1), EndMember, StartMember, HGroupObject, Spacing(4), HOffset(4), StartMember, /* Grid */ wtgroup = VGroupObject, StartMember, HGroupObject, StartMember, weights[0][0] = Integer(NULL,0,3,GID_W00), EndMember, StartMember, weights[0][1] = Integer(NULL,0,3,GID_W01), EndMember, StartMember, weights[0][2] = Integer(NULL,0,3,GID_W02), EndMember, StartMember, weights[0][3] = Integer(NULL,0,3,GID_W03), EndMember, StartMember, weights[0][4] = Integer(NULL,0,3,GID_W04), EndMember, StartMember, weights[0][5] = Integer(NULL,0,3,GID_W05), EndMember, StartMember, weights[0][6] = Integer(NULL,0,3,GID_W06), EndMember, EndObject, EndMember, StartMember, HGroupObject, StartMember, weights[1][0] = Integer(NULL,0,3,GID_W10), EndMember, StartMember, weights[1][1] = Integer(NULL,0,3,GID_W11), EndMember, StartMember, weights[1][2] = Integer(NULL,0,3,GID_W12), EndMember, StartMember, weights[1][3] = Integer(NULL,0,3,GID_W13), EndMember, StartMember, weights[1][4] = Integer(NULL,0,3,GID_W14), EndMember, StartMember, weights[1][5] = Integer(NULL,0,3,GID_W15), EndMember, StartMember, weights[1][6] = Integer(NULL,0,3,GID_W16), EndMember, EndObject, EndMember, StartMember, HGroupObject, StartMember, weights[2][0] = Integer(NULL,0,3,GID_W20), EndMember, StartMember, weights[2][1] = Integer(NULL,0,3,GID_W21), EndMember, StartMember, weights[2][2] = Integer(NULL,0,3,GID_W22), EndMember, StartMember, weights[2][3] = Integer(NULL,0,3,GID_W23), EndMember, StartMember, weights[2][4] = Integer(NULL,0,3,GID_W24), EndMember, StartMember, weights[2][5] = Integer(NULL,0,3,GID_W25), EndMember, StartMember, weights[2][6] = Integer(NULL,0,3,GID_W26), EndMember, EndObject, EndMember, StartMember, HGroupObject, StartMember, weights[3][0] = Integer(NULL,0,3,GID_W30), EndMember, StartMember, weights[3][1] = Integer(NULL,0,3,GID_W31), EndMember, StartMember, weights[3][2] = Integer(NULL,0,3,GID_W32), EndMember, StartMember, weights[3][3] = Integer(NULL,1,3,GID_W33), EndMember, StartMember, weights[3][4] = Integer(NULL,0,3,GID_W34), EndMember, StartMember, weights[3][5] = Integer(NULL,0,3,GID_W35), EndMember, StartMember, weights[3][6] = Integer(NULL,0,3,GID_W36), EndMember, EndObject, EndMember, StartMember, HGroupObject, StartMember, weights[4][0] = Integer(NULL,0,3,GID_W40), EndMember, StartMember, weights[4][1] = Integer(NULL,0,3,GID_W41), EndMember, StartMember, weights[4][2] = Integer(NULL,0,3,GID_W42), EndMember, StartMember, weights[4][3] = Integer(NULL,0,3,GID_W43), EndMember, StartMember, weights[4][4] = Integer(NULL,0,3,GID_W44), EndMember, StartMember, weights[4][5] = Integer(NULL,0,3,GID_W45), EndMember, StartMember, weights[4][6] = Integer(NULL,0,3,GID_W46), EndMember, EndObject, EndMember, StartMember, HGroupObject, StartMember, weights[5][0] = Integer(NULL,0,3,GID_W50), EndMember, StartMember, weights[5][1] = Integer(NULL,0,3,GID_W51), EndMember, StartMember, weights[5][2] = Integer(NULL,0,3,GID_W52), EndMember, StartMember, weights[5][3] = Integer(NULL,0,3,GID_W53), EndMember, StartMember, weights[5][4] = Integer(NULL,0,3,GID_W54), EndMember, StartMember, weights[5][5] = Integer(NULL,0,3,GID_W55), EndMember, StartMember, weights[5][6] = Integer(NULL,0,3,GID_W56), EndMember, EndObject, EndMember, StartMember, HGroupObject, StartMember, weights[6][0] = Integer(NULL,0,3,GID_W60), EndMember, StartMember, weights[6][1] = Integer(NULL,0,3,GID_W61), EndMember, StartMember, weights[6][2] = Integer(NULL,0,3,GID_W62), EndMember, StartMember, weights[6][3] = Integer(NULL,0,3,GID_W63), EndMember, StartMember, weights[6][4] = Integer(NULL,0,3,GID_W64), EndMember, StartMember, weights[6][5] = Integer(NULL,0,3,GID_W65), EndMember, StartMember, weights[6][6] = Integer(NULL,0,3,GID_W66), EndMember, EndObject, EndMember, StartMember, HGroupObject, Spacing(4), StartMember, Bias = Integer("Bias:",0,4,GID_BIAS), EndMember, StartMember, Div = Integer("Div:",1,4,GID_DIV), EndMember, EndObject, EndMember, EndObject, Weight(75), EndMember, StartMember, VGroupObject, Spacing(4), StartMember, XenButton("Load",GID_LOAD), EndMember, StartMember, XenButton("Save",GID_SAVE), EndMember, StartMember, XenButton("Clear",GID_CLEAR), EndMember, StartMember, XenButton("Convolute!",GID_OK), EndMember, StartMember, XenButton("Cancel",GID_CANCEL), EndMember, EndObject, Weight(10), EndMember, EndObject, EndMember, EndObject, /* MasterVGroup */ EndObject; /* Window */ if(Win) { #ifdef DEBUG_MODE PDebug("\tSucceeded in creating window\n"); #endif for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) { SetGadgetAttrs( (struct Gadget *)weights[i][j], NULL, NULL, STRINGA_LongVal, cargs->weights[i][j], TAG_DONE ); } } SetGadgetAttrs( (struct Gadget *)Bias, NULL, NULL, STRINGA_LongVal, cargs->bias, TAG_DONE); SetGadgetAttrs( (struct Gadget *)Div, NULL, NULL, STRINGA_LongVal, cargs->div, TAG_DONE); SetGadgetAttrs( (struct Gadget *)Name, NULL, NULL, INFO_TextFormat, cargs->name, TAG_DONE); if( win = WindowOpen( Win ) ) { #ifdef DEBUG_MODE PDebug("\tOpened window OK\n"); #endif Frq = FileReqObject, ASLFR_Window, win, ASLFR_SleepWindow, TRUE, ASLFR_InitialDrawer, "PROGDIR:modules/convolutions", ASLFR_InitialPattern,"~(#?.info)", EndObject; GetAttr( WINDOW_SigMask, Win, &sigmask ); while(!quit) { sig = Wait(sigmask | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_F); /* * Break signal */ if( sig & SIGBREAKF_CTRL_C ) { quit = TRUE; res = PERR_BREAK; } if( sig & SIGBREAKF_CTRL_F ) { WindowToFront( win ); ActivateWindow( win ); } /* * Gadget message */ if( sig & sigmask ) { while(( rc = HandleEvent( Win )) != WMHI_NOMORE ) { struct TagItem clrtable[] = { STRINGA_LongVal, 0, TAG_END }; struct TagItem nonametable[] = { INFO_TextFormat, (ULONG)"unnamed", TAG_END }; struct TagItem settable[] = {STRINGA_LongVal, 0, TAG_END }; struct TagItem frqloadtable[] = {ASLFR_DoSaveMode, FALSE, TAG_END }; struct TagItem newnametable[] = {INFO_TextFormat, NULL, TAG_END }; struct TagItem frqsavetable[] = {ASLFR_DoSaveMode, TRUE, TAG_END }; struct TagItem nametable[] = {INFO_TextFormat, NULL, TAG_END }; int id; switch(rc) { case WMHI_CLOSEWINDOW: case GID_CANCEL: res = PERR_CANCELED; quit = TRUE; WindowClose(Win); break; case GID_CLEAR: WindowBusy(Win); clrtable[0].ti_Data = 0; SetGadgetAttrsA( (struct Gadget *)Bias, win, NULL, clrtable); for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) { SetGadgetAttrsA( (struct Gadget *)weights[i][j], win, NULL, clrtable ); cargs->weights[i][j] = 0; } } clrtable[0].ti_Data = 1; /* For Divisor & Middle value. */ SetGadgetAttrsA( (struct Gadget *)weights[3][3], win, NULL, clrtable ); cargs->weights[3][3] = 1; clrtable[0].ti_Data = 1; /* For Divisor */ SetGadgetAttrsA( (struct Gadget *)Div, win, NULL, clrtable); SetGadgetAttrsA( (struct Gadget *) Name, win, NULL, nonametable); WindowReady(Win); break; case GID_LOAD: SetAttrsA( Frq, frqloadtable ); if(DoRequest( Frq ) == FRQ_OK) { GetAttr( FRQ_Path, Frq, (ULONG *)&name ); WindowBusy(Win); if(LoadConvFilter( xd, name, cargs ) == PERR_OK ) { for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) { settable[0].ti_Data = cargs->weights[i][j]; SetGadgetAttrsA( (struct Gadget *)weights[i][j], win, NULL, settable ); } } settable[0].ti_Data = cargs->bias; SetGadgetAttrsA( (struct Gadget *)Bias, win, NULL, settable); settable[0].ti_Data = cargs->div; SetGadgetAttrsA( (struct Gadget *)Div, win, NULL, settable); GetAttr( FRQ_File, Frq, (ULONG *) &newnametable[0].ti_Data ); SetGadgetAttrsA( (struct Gadget *) Name, win, NULL, newnametable); } WindowReady(Win); } break; case GID_SAVE: SetAttrsA( Frq, frqsavetable ); if(DoRequest(Frq) == FRQ_OK) { WindowBusy(Win); GetAttr( FRQ_Path, Frq, (ULONG *)&name ); for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) { GetAttr( STRINGA_LongVal, weights[i][j], (ULONG *) &(cargs->weights[i][j]) ); } } GetAttr( STRINGA_LongVal, Bias, (ULONG *) &(cargs->bias)); GetAttr( STRINGA_LongVal, Div, (ULONG *) &(cargs->div)); SaveConvFilter( xd, name, cargs ); GetAttr( FRQ_File, Frq, &nametable[0].ti_Data ); SetGadgetAttrsA( (struct Gadget *) Name, win, NULL, nametable); WindowReady(Win); } break; case GID_OK: GetAttr( STRINGA_LongVal, Bias, (ULONG *) &(cargs->bias)); GetAttr( STRINGA_LongVal, Div, (ULONG *) &(cargs->div)); GetAttr( WINDOW_Bounds, Win, (ULONG *) &(cargs->winpos) ); if( cargs->div != 0 ) { WindowClose(Win); for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) { GetAttr( STRINGA_LongVal, weights[i][j], (ULONG *) &(cargs->weights[i][j]) ); } } GetAttr( STRINGA_LongVal, Bias, (ULONG *) &(cargs->bias)); GetAttr( STRINGA_LongVal, Div, (ULONG *) &(cargs->div)); strncpy( cargs->name, name, 40 ); res = PERR_OK; quit = TRUE; } break; default: if(rc >= OPR(0) && rc <= OPR(1000)) { /* It's a default opr */ WindowBusy(Win); for(id = 0; presets[id].id != rc && presets[id].id != 0L; id++); /* Fetch correct area. */ if(presets[id].id) { for(i = 0; i < 7; i++) { for(j = 0; j < 7; j++) { settable[0].ti_Data = cargs->weights[i][j] = presets[id].weights[i][j]; SetGadgetAttrsA( (struct Gadget *)weights[i][j], win, NULL, settable ); } } settable[0].ti_Data = cargs->bias = presets[id].bias; SetGadgetAttrsA( (struct Gadget *)Bias, win, NULL, settable); settable[0].ti_Data = cargs->div = presets[id].div; SetGadgetAttrsA( (struct Gadget *)Div, win, NULL, settable); newnametable[0].ti_Data = name = (ULONG)presets[id].name; SetGadgetAttrsA( (struct Gadget *)Name, win, NULL, newnametable); } #ifdef DEBUG_MODE else { PDebug("Serious software error!!!\n"); } #endif WindowReady(Win); } break; } /* switch */ } /* while */ } /* sig & sigmask */ } /* while(!quit) */ DisposeObject(Win); DisposeObject(Frq); } else { #ifdef DEBUG_MODE PDebug("\tFailed to get window\n"); #endif DisposeObject(Win); return PERR_WONTOPEN; } } else { #ifdef DEBUG_MODE PDebug("\tFailed to get window object\n"); #endif return PERR_WONTOPEN; } return res; }
IPTR PUBLIC DispatchScrollerGadget(REG(a0, Class *cl), REG(a2, Object *o), REG(a1, Msg msg)) { struct ScrollerGData *sd; struct ClassBase *cb; IPTR retval = 0; sd = INST_DATA(cl,o); cb = (APTR)cl->cl_UserData; switch(msg->MethodID) { case OM_NEW: if ((retval = DoSuperMethodA(cl,o,msg)) != 0) { struct Gadget *gad = (struct Gadget *)retval; sd = INST_DATA(cl,retval); if (DispatchScrollerNew(cb,sd,gad,(struct opSet *)msg)) { //gad->NextGadget = sd->sd_Down; SetAttrs((APTR)retval,GA_Left, gad->LeftEdge+4, GA_Top, gad->TopEdge+2, GA_Width, gad->Width-8, GA_Height, gad->Height-2*sd->sd_UpImage->Height-4, PGA_Total, GetTagData(PGA_Total,0,((struct opSet *)msg)->ops_AttrList), GA_RelVerify, TRUE, TAG_END); } else { DoMethod(o,OM_DISPOSE); retval = 0; } } break; case OM_UPDATE: { struct opUpdate *opu = (APTR)msg; long move = 0; retval = DoSuperMethodA(cl,o,msg); if ((move = -GetTagData(SGA_Up,0,opu->opu_AttrList)) != 0) if (!(sd->sd_Up->Flags & GFLG_SELECTED)) move = 0; if (!move && (move = GetTagData(SGA_Down,0,opu->opu_AttrList))) if (!(sd->sd_Down->Flags & GFLG_SELECTED)) move = 0; if (move) { long top; if (GetAttr(PGA_Top,o,(IPTR *)&top)) { top += move; if (top >= 0) { struct RastPort *rp = ObtainGIRPort(opu->opu_GInfo); struct TagItem tags[] = {{PGA_Top,0},{TAG_END}}; SetAttrs(o,PGA_Top,top,TAG_END); GetAttr(PGA_Top,o,&tags[0].ti_Data); DoSuperMethod(cl,o,OM_NOTIFY,tags,opu->opu_GInfo,0); DoSuperMethod(cl,o,GM_RENDER,opu->opu_GInfo,rp,GREDRAW_UPDATE); ReleaseGIRPort(rp); } } } break; } case OM_DISPOSE: DisposeObject(sd->sd_UpImage); DisposeObject(sd->sd_DownImage); DisposeObject(sd->sd_Up); DisposeObject(sd->sd_Down); DisposeObject(sd->sd_Frame); retval = DoSuperMethodA(cl,o,msg); break; case GM_RENDER: { struct gpRender *gpr = (struct gpRender *)msg; DrawImage(gpr->gpr_RPort,sd->sd_Frame,0,0); retval = DoSuperMethodA(cl,o,msg); break; } default: retval = DoSuperMethodA(cl,o,msg); } return(retval); }
int startup(int argc, char *argv[]) { int i, len; FULL_CHAR *arg; OBJECT t, y, res, s; /* current token, parser output */ BOOLEAN stdin_seen; /* TRUE when stdin file seen */ int source_file_count; /* number of source files in command */ FULL_CHAR *cross_db; /* name of cross reference database */ FULL_CHAR *outfile; /* name of output file */ FULL_CHAR *lib; /* name of library directory */ FILE *out_fp; long MemCheckLong; FULL_CHAR oname[MAX_BUFF], oval[MAX_BUFF], buff[MAX_BUFF], *p; int bp; OBJECT z; BOOLEAN seen_wordcount; #if LOCALE_ON char catname[MAX_BUFF], *loc; #endif /* find the name of the library directory, from envt or else from -D */ lib = AsciiToFull(getenv("LOUTLIB")); if( lib == (FULL_CHAR *) NULL ) lib = AsciiToFull(LIB_DIR); /* set locale if that's what we are doing */ #if LOCALE_ON loc = setlocale(LC_MESSAGES, ""); if( loc == (char *) NULL ) { Error(1, 6, "unable to initialize locale", WARN, no_fpos); loc = "C"; } sprintf(catname, "%s/%s/%s/LC_MESSAGES/errors.%s", lib, LOCALE_DIR, loc, loc); MsgCat = catopen(catname, 0); #endif /* initialise various modules, add current directory to search paths */ TotalWordCount = 0; seen_wordcount = FALSE; BackEnd = PS_BackEnd; PlainCharWidth = PLAIN_WIDTH; PlainCharHeight = PLAIN_HEIGHT; PlainFormFeed = FALSE; InitializeAll = FALSE; UseCollate = COLLATE; AllowCrossDb = TRUE; InMemoryDbIndexes = TRUE; Encapsulated = FALSE; SafeExecution = SAFE_DFT ? TRUE : FALSE; Kern = TRUE; MemInit(); InitSym(); LexInit(); InitFiles(); AddToPath(SOURCE_PATH, MakeWord(WORD, STR_EMPTY, no_fpos)); AddToPath(DATABASE_PATH, MakeWord(WORD, STR_EMPTY, no_fpos)); AddToPath(INCLUDE_PATH, MakeWord(WORD, STR_EMPTY, no_fpos)); /* read command line */ stdin_seen = FALSE; AltErrorFormat = FALSE; cross_db = CROSS_DB; outfile = STR_STDOUT; source_file_count = 0; New(CommandOptions, ACAT); for( i = 1; i < argc; i++ ) { if( *argv[i] == CH_HYPHEN ) switch( *(argv[i]+1) ) { case CH_FLAG_OUTFILE: /* read name of output file */ if( (outfile = GetArg(argv, argc, &i)) == NULL ) Error(1, 7, "usage: -o <filename>", FATAL, no_fpos); if( StringEndsWith(outfile, SOURCE_SUFFIX) ) Error(1, 28, "-o: output file name %s ends with %s", FATAL, no_fpos, outfile, SOURCE_SUFFIX); break; case CH_FLAG_SUPPRESS: /* suppress references to OldCrossDb and NewCrossDb */ AllowCrossDb = FALSE; break; case CH_FLAG_MEMCR: /* don't use in-memory database indexes */ InMemoryDbIndexes = FALSE; break; case CH_FLAG_NOKERN: /* suppress kerning */ Kern = FALSE; break; case CH_FLAG_NOCOLLATE: /* suppress local collation */ UseCollate = FALSE; break; case CH_FLAG_COLLATE: /* invoke local collation */ UseCollate = TRUE; break; case CH_FLAG_CROSS: /* read name of cross reference database */ if( (cross_db = GetArg(argv, argc, &i)) == NULL ) Error(1, 8, "usage: -c <filename>", FATAL, no_fpos); break; case CH_FLAG_ERRFILE: /* read log file name */ if( (arg = GetArg(argv, argc, &i)) == NULL ) Error(1, 9, "usage: -e <filename>", FATAL, no_fpos); ErrorInit(arg); break; case CH_FLAG_ALTERR: /* alternative error message format */ AltErrorFormat = TRUE; break; case CH_FLAG_EPSFIRST: /* -EPS produces encapsulated PostScript output */ if( !StringEqual(AsciiToFull(argv[i]+1), STR_EPS) ) Error(1, 10, "usage: -EPS", FATAL, no_fpos); Encapsulated = TRUE; break; case CH_FLAG_DIRPATH: /* add directory to database and sysdatabase paths */ if( (arg = GetArg(argv, argc, &i)) == NULL ) Error(1, 11, "usage: -D <directoryname>", FATAL, no_fpos); AddToPath(DATABASE_PATH, MakeWord(WORD, arg, no_fpos)); AddToPath(SYSDATABASE_PATH, MakeWord(WORD, arg, no_fpos)); break; case CH_FLAG_ENCPATH: /* add directory to character mapping path */ if( (arg = GetArg(argv, argc, &i)) == NULL ) Error(1, 12, "usage: -C <directoryname>", FATAL, no_fpos); AddToPath(MAPPING_PATH, MakeWord(WORD, arg, no_fpos)); break; case CH_FLAG_FNTPATH: /* add directory to font path */ if( (arg = GetArg(argv, argc, &i)) == NULL ) Error(1, 13, "usage: -F <directoryname>", FATAL, no_fpos); AddToPath(FONT_PATH, MakeWord(WORD, arg, no_fpos)); break; case CH_FLAG_HYPPATH: /* add directory to hyph path */ if( (arg = GetArg(argv, argc, &i)) == NULL ) Error(1, 14, "usage: -H <directoryname>", FATAL, no_fpos); AddToPath(HYPH_PATH, MakeWord(WORD, arg, no_fpos)); break; case CH_FLAG_INCPATH: /* add directory to include and sysinclude paths */ if( (arg = GetArg(argv, argc, &i)) == NULL ) Error(1, 15, "usage: -I <directoryname>", FATAL, no_fpos); AddToPath(INCLUDE_PATH, MakeWord(WORD, arg, no_fpos)); AddToPath(SYSINCLUDE_PATH, MakeWord(WORD, arg, no_fpos)); break; case CH_FLAG_INCLUDE: /* read sysinclude file and strip any .lt suffix */ if( (arg = GetArg(argv, argc, &i)) == NULL ) Error(1, 16, "usage: -i <filename>", FATAL, no_fpos); len = StringLength(arg) - StringLength(SOURCE_SUFFIX); if( len >= 0 && StringEqual(&arg[len], SOURCE_SUFFIX) ) StringCopy(&arg[len], STR_EMPTY); debug0(DFS, D, " calling DefineFile from main (1)"); DefineFile(arg, STR_EMPTY, no_fpos, SOURCE_FILE, SYSINCLUDE_PATH); break; case CH_FLAG_HYPHEN: /* declare hyphenation file */ if( FirstFile(HYPH_FILE) != NO_FILE ) Error(1, 17, "two -h options illegal", FATAL, no_fpos); if( (arg = GetArg(argv, argc, &i)) == NULL ) Error(1, 18, "usage: -h <filename>", FATAL, no_fpos); debug0(DFS, D, " calling DefineFile from main (2)"); DefineFile(arg, STR_EMPTY, no_fpos, HYPH_FILE, INCLUDE_PATH); DefineFile(arg, HYPH_SUFFIX, no_fpos, HYPH_PACKED_FILE, INCLUDE_PATH); break; case CH_FLAG_VERSION: fprintf(stderr, "%s\n", LOUT_VERSION); fprintf(stderr, "%-28s %s\n", "Basser Lout written by:", "Jeffrey H. Kingston ([email protected])"); fprintf(stderr, "%-28s %s\n", "Free source available from:", "ftp://ftp.cs.usyd.edu.au/jeff/lout"); fprintf(stderr, "%-28s %s %s\n", "This executable compiled:", __TIME__, __DATE__); fprintf(stderr, "%-28s %s%s%s\n", "System include directory:", lib, STR_DIR, INCL_DIR); fprintf(stderr, "%-28s %s%s%s\n", "System database directory:", lib, STR_DIR, DATA_DIR); fprintf(stderr, "Database index files created afresh automatically:%s\n", USE_STAT ? " yes" : " no"); fprintf(stderr, "Safe execution (disabling system()) is default:%s\n", SAFE_DFT ? " yes" : " no"); fprintf(stderr, "strcoll() used for sorting by default:%s\n", COLLATE ? " yes" : " no"); fprintf(stderr, "PDF compression on:%s\n", PDF_COMPRESSION ? " yes" : " no"); fprintf(stderr, "Debugging (-d, -dd, -ddd flags) available:%s\n", DEBUG_ON ? " yes" : " no"); fprintf(stderr, "\n"); fprintf(stderr, "Basser Lout comes with ABSOLUTELY NO WARRANTY.\n"); fprintf(stderr, "This is free software, and you are welcome to\n"); fprintf(stderr, "redistribute it under certain conditions. For\n"); fprintf(stderr, "details on both points, consult the GNU General\n"); fprintf(stderr, "Public License (distributed with this software).\n"); exit(0); break; case CH_FLAG_WORDS: seen_wordcount = TRUE; break; case CH_FLAG_PDF: BackEnd = PDF_BackEnd; break; case CH_FLAG_FFPLAIN: if( StringEqual(AsciiToFull(argv[i]+1), STR_PDF) ) { BackEnd = PDF_BackEnd; break; } PlainFormFeed = TRUE; /* NB NO BREAK */ case CH_FLAG_PLAIN: BackEnd = Plain_BackEnd; if( *(argv[i]+2) != '\0' ) { float len1, len2; FULL_CHAR units1, units2; if( sscanf(argv[i]+2, "%f%c%f%c",&len1,&units1,&len2,&units2) != 4 ) { Error(1, 19, "usage: lout -%c<length><length>", FATAL, no_fpos, *(argv[i]+1)); } switch( units1 ) { case CH_UNIT_CM: PlainCharWidth = len1 * CM; break; case CH_UNIT_IN: PlainCharWidth = len1 * IN; break; case CH_UNIT_PT: PlainCharWidth = len1 * PT; break; case CH_UNIT_EM: PlainCharWidth = len1 * EM; break; default: Error(1, 20, "lout -%c: units must be c, i, p, or m", FATAL, no_fpos, *(argv[i]+1)); break; } switch( units2 ) { case CH_UNIT_CM: PlainCharHeight = len2 * CM; break; case CH_UNIT_IN: PlainCharHeight = len2 * IN; break; case CH_UNIT_PT: PlainCharHeight = len2 * PT; break; case CH_UNIT_EM: PlainCharHeight = len2 * EM; break; default: Error(1, 21, "lout -%c: units must be c, i, p, or m", FATAL, no_fpos, *(argv[i]+1)); break; } } break; case CH_FLAG_INITALL: InitializeAll = TRUE; AllowCrossDb = FALSE; break; case CH_FLAG_USAGE: PrintUsage(stderr); exit(0); break; case CH_FLAG_DEBUG: debug_init(AsciiToFull(argv[i])); break; case CH_FLAG_MEMCHECK: sscanf(argv[i], "-m%ld", &MemCheckLong); MemCheck = (POINTER) MemCheckLong; fprintf(stderr, "checking memory location %ld\n", (long) MemCheck); break; case '\0': /* read stdin as file name */ if( stdin_seen ) Error(1, 23, "standard input specified twice", FATAL, no_fpos); stdin_seen = TRUE; debug0(DFS, D, " calling DefineFile from main (3)"); DefineFile(STR_STDIN, STR_EMPTY, no_fpos, SOURCE_FILE, SOURCE_PATH); break; case CH_FLAG_OPTION: /* read command-line document option */ if( sscanf(argv[i]+2, "%[^{ ] { %[^}] }", oname, oval) != 2 || StringLength(oname) == 0 || StringLength(oval) == 0 ) Error(1, 24, "error in command-line option %s", FATAL, no_fpos, argv[i]+2); y = MakeWord(WORD, oname, no_fpos); Link(CommandOptions, y); New(y, ACAT); Link(CommandOptions, y); bp = 0; for( p = oval; *p != '\0'; p++ ) switch( *p ) { case ' ': case '\t': case '\n': case '{': case '}': if( bp > 0 ) { buff[bp++] = '\0'; if( Down(y) != y ) { OBJECT g; New(g, GAP_OBJ); hspace(g) = 1; vspace(g) = 0; FposCopy(fpos(g), *no_fpos); Link(y, g); } z = MakeWord(WORD, buff, no_fpos); Link(y, z); bp = 0; } break; default: buff[bp++] = *p; break; } if( bp > 0 ) { buff[bp++] = '\0'; z = MakeWord(WORD, buff, no_fpos); Link(y, z); } if( Down(y) == y ) Error(1, 25, "error in command-line option %s", FATAL, no_fpos, argv[i]+2); break; case CH_FLAG_SAFE: /* ensure safe execution by disabling system calls */ SafeExecution = TRUE; break; case CH_FLAG_UNSAFE: /* allow unsafe execution */ SafeExecution = FALSE; break; default: PrintUsage(stderr); Error(1, 26, "unknown command line flag %s", FATAL, no_fpos, argv[i]); break; } else { /* argument is source file, strip any .lout suffix and define it */ arg = AsciiToFull(argv[i]); len = StringLength(arg) - StringLength(SOURCE_SUFFIX); if( len >= 0 && StringEqual(&arg[len], SOURCE_SUFFIX) ) StringCopy(&arg[len], STR_EMPTY); debug0(DFS, D, " calling DefineFile from main (4)"); DefineFile(AsciiToFull(argv[i]), STR_EMPTY, no_fpos, SOURCE_FILE, SOURCE_PATH); source_file_count++; } } /* for */ if( UseCollate ) { if (!setlocale (LC_COLLATE, "")) Error(1, 30, "unable to initialize collation", WARN, no_fpos); } /* start timing if required */ ifdebug(DPP, D, ProfileOn("main")); /* open output file, or stdout if none specified, and initialize printer */ if( StringEqual(outfile, STR_STDOUT) ) { #if OS_DOS /* For DOS/Win32 we need to set binary mode on stdout to prevent PDF compressed streams and xrefs from being corrupted - Uwe 12/98 */ if( BackEnd->code != PLAINTEXT && _setmode(_fileno(stdout), _O_BINARY) == -1 ) Error(1, 31, "cannot set binary mode on stdout", FATAL, no_fpos); #endif out_fp = stdout; } else { out_fp = StringFOpen(outfile, BackEnd->code == PLAINTEXT ? WRITE_TEXT : WRITE_BINARY); if( out_fp == null ) Error(1, 27, "cannot open output file %s", FATAL, no_fpos, outfile); } /* initialize miscellaneous modules */ ColourInit(); LanguageInit(); BackEnd->PrintInitialize(out_fp); /* append default directories to file search paths */ AddToPath(FONT_PATH, MakeWordThree(lib, STR_DIR, AsciiToFull(FONT_DIR))); AddToPath(HYPH_PATH, MakeWordThree(lib, STR_DIR, AsciiToFull(HYPH_DIR))); AddToPath(MAPPING_PATH, MakeWordThree(lib, STR_DIR, AsciiToFull(MAPS_DIR))); AddToPath(SYSDATABASE_PATH,MakeWordThree(lib,STR_DIR, AsciiToFull(DATA_DIR))); AddToPath(DATABASE_PATH, MakeWordThree(lib, STR_DIR, AsciiToFull(DATA_DIR))); AddToPath(SYSINCLUDE_PATH,MakeWordThree(lib, STR_DIR, AsciiToFull(INCL_DIR))); AddToPath(INCLUDE_PATH, MakeWordThree(lib, STR_DIR, AsciiToFull(INCL_DIR))); /* use stdin if no source files were mentioned */ if( source_file_count == 0 ) { debug0(DFS, D, " calling DefineFile from main (5)"); DefineFile(STR_STDIN, STR_EMPTY, no_fpos, SOURCE_FILE, SOURCE_PATH); } /* load predefined symbols into symbol table */ StartSym = nilobj; /* Not a mistake */ StartSym = load(KW_START, 0, FALSE, FALSE, TRUE, NO_PREC ); GalleySym = load(KW_GALLEY, 0, FALSE, FALSE, TRUE, NO_PREC ); ForceGalleySym= load(KW_FORCE_GALLEY, 0, FALSE, FALSE, TRUE, NO_PREC ); InputSym = load(KW_INPUT, 0, FALSE, FALSE, TRUE, NO_PREC ); PrintSym = load(KW_PRINT, 0, FALSE, FALSE, TRUE, NO_PREC ); FilterInSym = load(KW_FILTERIN, 0, FALSE, FALSE, FALSE, NO_PREC ); FilterOutSym = load(KW_FILTEROUT, 0, FALSE, FALSE, FALSE, NO_PREC ); FilterErrSym = load(KW_FILTERERR, 0, FALSE, FALSE, FALSE, NO_PREC ); OptGallSym = load(KW_OPTGALL, 0, FALSE, TRUE, FALSE, DEFAULT_PREC); VerbatimSym = load(KW_VERBATIM,VERBATIM,FALSE, TRUE, FALSE, DEFAULT_PREC); RawVerbatimSym= load(KW_RAWVERBATIM,RAW_VERBATIM,FALSE,TRUE,FALSE,DEFAULT_PREC); load(KW_BEGIN, BEGIN, FALSE, FALSE, FALSE, BEGIN_PREC ); load(KW_END, END, FALSE, FALSE, FALSE, END_PREC ); load(KW_ENV, ENV, FALSE, FALSE, FALSE, NO_PREC ); load(KW_ENVA, ENVA, FALSE, FALSE, FALSE, NO_PREC ); load(KW_ENVB, ENVB, FALSE, FALSE, FALSE, NO_PREC ); load(KW_ENVC, ENVC, FALSE, FALSE, FALSE, NO_PREC ); load(KW_ENVD, ENVD, FALSE, FALSE, FALSE, NO_PREC ); load(KW_CENV, CENV, FALSE, FALSE, FALSE, NO_PREC ); load(KW_CLOS, CLOS, FALSE, FALSE, FALSE, NO_PREC ); load(KW_LVIS, LVIS, FALSE, FALSE, FALSE, NO_PREC ); load(KW_LUSE, LUSE, FALSE, FALSE, FALSE, NO_PREC ); load(KW_LEO, LEO, FALSE, FALSE, FALSE, NO_PREC ); load(KW_LBR, LBR, FALSE, FALSE, FALSE, LBR_PREC ); load(KW_RBR, RBR, FALSE, FALSE, FALSE, RBR_PREC ); load(KW_INCLUDE, INCLUDE, FALSE, FALSE, FALSE, NO_PREC ); load(KW_SYSINCLUDE, SYS_INCLUDE, FALSE, FALSE, FALSE, NO_PREC ); load(KW_PREPEND, PREPEND, FALSE, FALSE, FALSE, NO_PREC ); load(KW_SYSPREPEND, SYS_PREPEND, FALSE, FALSE, FALSE, NO_PREC ); load(KW_DATABASE, DATABASE, FALSE, FALSE, FALSE, NO_PREC ); load(KW_SYSDATABASE, SYS_DATABASE, FALSE, FALSE, FALSE, NO_PREC ); load(KW_USE, USE, FALSE, FALSE, FALSE, NO_PREC ); load(KW_NOT_REVEALED, NOT_REVEALED, FALSE, FALSE, FALSE, NO_PREC ); load(KW_CASE, CASE, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_YIELD, YIELD, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_BACKEND, BACKEND, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_XCHAR, XCHAR, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_FONT, FONT, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_SPACE, SPACE, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_YUNIT, YUNIT, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_ZUNIT, ZUNIT, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_BREAK, BREAK, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_UNDERLINE, UNDERLINE, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_COLOUR, COLOUR, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_COLOR, COLOUR, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_OUTLINE, OUTLINE, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_LANGUAGE, LANGUAGE, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_CURR_LANG, CURR_LANG, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_CURR_FAMILY, CURR_FAMILY, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_CURR_FACE, CURR_FACE, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_CURR_YUNIT, CURR_YUNIT, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_CURR_ZUNIT, CURR_ZUNIT, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_COMMON, COMMON, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_RUMP, RUMP, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_MELD, MELD, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_INSERT, INSERT, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_ONE_OF, ONE_OF, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_NEXT, NEXT, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_PLUS, PLUS, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_MINUS, MINUS, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_OPEN, OPEN, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_TAGGED, TAGGED, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_WIDE, WIDE, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_HIGH, HIGH, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_HSHIFT, HSHIFT, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_VSHIFT, VSHIFT, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_BEGIN_HEADER, BEGIN_HEADER, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_END_HEADER, END_HEADER, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_SET_HEADER, SET_HEADER, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_CLEAR_HEADER, CLEAR_HEADER, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_ONE_COL, ONE_COL, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_ONE_ROW, ONE_ROW, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_HSCALE, HSCALE, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_VSCALE, VSCALE, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_HCOVER, HCOVER, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_VCOVER, VCOVER, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_KERN_SHRINK, KERN_SHRINK, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_SCALE, SCALE, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_HCONTRACT, HCONTRACT, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_VCONTRACT, VCONTRACT, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_HLIMITED, HLIMITED, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_VLIMITED, VLIMITED, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_HEXPAND, HEXPAND, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_VEXPAND, VEXPAND, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_STARTHVSPAN, START_HVSPAN, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_STARTHSPAN, START_HSPAN, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_STARTVSPAN, START_VSPAN, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_HSPAN, HSPAN, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_VSPAN, VSPAN, FALSE, FALSE, FALSE, DEFAULT_PREC); load(KW_PADJUST, PADJUST, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_HADJUST, HADJUST, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_VADJUST, VADJUST, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_ROTATE, ROTATE, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_BACKGROUND, BACKGROUND, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_INCGRAPHIC, INCGRAPHIC, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_SINCGRAPHIC, SINCGRAPHIC, FALSE, TRUE, FALSE, DEFAULT_PREC); load(KW_PLAINGRAPHIC, PLAIN_GRAPHIC, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_GRAPHIC, GRAPHIC, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_LINK_SOURCE, LINK_SOURCE, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_LINK_DEST, LINK_DEST, TRUE, TRUE, FALSE, DEFAULT_PREC); load(KW_CROSS, CROSS, TRUE, TRUE, FALSE, CROSSOP_PREC); load(KW_FORCE_CROSS, FORCE_CROSS, TRUE, TRUE, FALSE, CROSSOP_PREC); load(KW_NULL, NULL_CLOS, FALSE, FALSE, TRUE, NO_PREC ); load(KW_PAGE_LABEL, PAGE_LABEL, FALSE, TRUE, TRUE, DEFAULT_PREC); #define setcat(s, mk, jn) has_mark(s)=mk, has_join(s)=jn s=load(KW_VCAT_NN, VCAT, TRUE, TRUE, FALSE, VCAT_PREC); setcat(s,FALSE,FALSE); s=load(KW_VCAT_MN, VCAT, TRUE, TRUE, FALSE, VCAT_PREC); setcat(s,TRUE, FALSE); s=load(KW_VCAT_NJ, VCAT, TRUE, TRUE, FALSE, VCAT_PREC); setcat(s,FALSE,TRUE); s=load(KW_VCAT_MJ, VCAT, TRUE, TRUE, FALSE, VCAT_PREC); setcat(s,TRUE, TRUE); s=load(KW_HCAT_NN, HCAT, TRUE, TRUE, FALSE, HCAT_PREC); setcat(s,FALSE,FALSE); s=load(KW_HCAT_MN, HCAT, TRUE, TRUE, FALSE, HCAT_PREC); setcat(s,TRUE, FALSE); s=load(KW_HCAT_NJ, HCAT, TRUE, TRUE, FALSE, HCAT_PREC); setcat(s,FALSE,TRUE); s=load(KW_HCAT_MJ, HCAT, TRUE, TRUE, FALSE, HCAT_PREC); setcat(s,TRUE, TRUE); s=load(KW_ACAT_NJ, ACAT, TRUE, TRUE, FALSE, ACAT_PREC); setcat(s,FALSE,TRUE); s=load(KW_ACAT_MJ, ACAT, TRUE, TRUE, FALSE, ACAT_PREC); setcat(s,TRUE, TRUE); /* intialize fonts and load @FontDef symbol */ FontInit(); /* intialize current time and load @Moment symbol */ InitTime(); /* initialize filter module */ FilterInit(); /* initialize enviroment table module */ EnvInit(); /* initialise scope chain to <StartSym> */ PushScope(StartSym, FALSE, FALSE); /* initialise lexical analyser */ LexPush(FirstFile(SOURCE_FILE), 0, SOURCE_FILE, 1, FALSE); /* process input files */ InitParser(cross_db); t = NewToken(BEGIN, no_fpos, 0, 0, BEGIN_PREC, StartSym); res = Parse(&t, StartSym, TRUE, TRUE); debug0(DGT, D, "calling TransferEnd(res) from main()"); DisposeObject(CommandOptions); TransferEnd(res); TransferClose(); /* close various modules */ BackEnd->PrintAfterLastPage(); BackEnd->LinkCheck(); CrossClose(); CloseFiles(); /* remove any leftover filter temporary files */ FilterScavenge(TRUE); /* print word count, if required */ if( seen_wordcount ) Error(1, 29, "total of all words printed: %d", WARN,no_fpos,TotalWordCount); /* check for unbalanced error blocks */ CheckErrorBlocks(); /* wrapup */ ifdebug(DST, DD, CheckSymSpread() ); ifdebug(ANY, D, DeleteEverySym() ); debug0(DMA, D, "at end of run:"); ifdebug(DMA, D, DebugMemory() ); ifdebug(DPP, D, ProfileOff("main")); ifdebug(DPP, D, ProfilePrint()); ifdebug(DET, D, EnvDebug()); #if LOCALE_ON catclose(MsgCat); #endif exit(0); return 0; } /* end main */
IPTR GTCheckBox__OM_SET(Class *cl, struct Gadget *g, struct opSet *msg) { struct CheckBoxData *data; struct TagItem *tag; const struct TagItem *taglist = msg->ops_AttrList; struct RastPort *rp; IPTR retval = FALSE; data = INST_DATA(cl, g); if (data->flags & CF_CustomImage) { tag = FindTagItem(GA_Image, taglist); if (tag) { DisposeObject(g->GadgetRender); g->GadgetRender = NULL; data->flags &= ~CF_CustomImage; } } if (msg->MethodID != OM_NEW) retval = DoSuperMethodA(cl, (Object *)g, (Msg)msg); while ((tag = NextTagItem(&taglist))) { switch (tag->ti_Tag) { case GA_Disabled: retval = TRUE; break; case GA_DrawInfo: if (msg->MethodID == OM_NEW) data->dri = (struct DrawInfo *) tag->ti_Data; break; case GA_Image: case GA_SelectRender: retval = TRUE; break; case GA_LabelPlace: if (msg->MethodID == OM_NEW) data->labelplace = (LONG)tag->ti_Data; break; case GTCB_Checked: if (tag->ti_Data) g->Flags |= GFLG_SELECTED; else g->Flags &= ~GFLG_SELECTED; retval = TRUE; break; } /* switch (tag->ti_Tag) */ } /* while ((tag = NextTagItem(&taglist))) */ if (g->Width == 0) g->Width = CHECKBOX_WIDTH; if (g->Height == 0) g->Height = CHECKBOX_HEIGHT; /* Redraw ourself? */ if ((retval) && (msg->MethodID != OM_NEW) && ((msg->MethodID != OM_UPDATE) || (OCLASS(g) == cl))) { rp = ObtainGIRPort(msg->ops_GInfo); if (rp) { DoMethod((Object *)g, GM_RENDER, (IPTR) msg->ops_GInfo, (IPTR) rp, GREDRAW_UPDATE); ReleaseGIRPort(rp); retval = FALSE; } } return retval; }
IPTR PUBLIC DispatchArrowImage(REG(a0, Class *cl), REG(a2, Object *o), REG(a1, Msg msg)) { struct ArrowIData *ad; struct ClassBase *cb; IPTR retval = 0; ad = INST_DATA(cl,o); cb = (APTR)cl->cl_UserData; switch(msg->MethodID) { case OM_NEW: if ((retval = DoSuperMethodA(cl,o,msg)) != 0) { IM(retval)->Width = GetTagData(IA_Width,16,((struct opSet *)msg)->ops_AttrList); IM(retval)->Height = GetTagData(IA_Height,13,((struct opSet *)msg)->ops_AttrList); if (IM(retval)->Width < 10) IM(retval)->Width = 10; if (IM(retval)->Height < 8) IM(retval)->Height = 8; ad = INST_DATA(cl,retval); ad->ad_Type = GetTagData(SYSIA_Which,0,((struct opSet *)msg)->ops_AttrList); ad->ad_Frame = NewObject(NULL,"frameiclass",IA_FrameType, FRAME_BUTTON, IA_Width, IM(retval)->Width, IA_Height, IM(retval)->Height, TAG_END); } break; case OM_DISPOSE: DisposeObject(ad->ad_Frame); retval = DoSuperMethodA(cl,o,msg); break; case IM_DRAW: case IM_DRAWFRAME: { struct impDraw *imp = (struct impDraw *)msg; long x,y,w,h; x = IM(o)->LeftEdge+imp->imp_Offset.X; y = IM(o)->TopEdge+imp->imp_Offset.Y; w = IM(o)->Width-9; h = IM(o)->Height-5; if (!(w % 2)) w++; DrawImageState(imp->imp_RPort,ad->ad_Frame,x,y,imp->imp_State,imp->imp_DrInfo); x += 4; y += 2; if (imp->imp_DrInfo) SetAPen(imp->imp_RPort,imp->imp_DrInfo->dri_Pens[TEXTPEN]); else SetAPen(imp->imp_RPort,1); if (ad->ad_Type == ADT_UP) { Move(imp->imp_RPort,x,y+h); /* up arrow */ Draw(imp->imp_RPort,x+w/2,y); Draw(imp->imp_RPort,x+w-1,y+h); Move(imp->imp_RPort,x+1,y+h); Draw(imp->imp_RPort,x+w/2+1,y); Draw(imp->imp_RPort,x+w,y+h); } else { Move(imp->imp_RPort,x,y); /* down arrow */ Draw(imp->imp_RPort,x+w/2,y+h); Draw(imp->imp_RPort,x+w-1,y); Move(imp->imp_RPort,x+1,y); Draw(imp->imp_RPort,x+w/2+1,y+h); Draw(imp->imp_RPort,x+w,y); } } break; default: retval = DoSuperMethodA(cl,o,msg); } return(retval); }
EFFECTEXEC(frame,tags,PPTBase,EffectBase) { ULONG sig, rc, *args; BOOL quit = FALSE, reallyrexx = FALSE; FRAME *newframe = NULL, *with = NULL; struct gFixRectMessage gfr = {0}; ULONG fc, wc; struct Values *av; D(bug(MYNAME": Exec()\n")); /* * Defaults */ v.ratio = 128; v.method = Direct; v.bounds.Top = v.bounds.Left = ~0; v.bounds.Width = 200; v.bounds.Height = 100; v.tile = FALSE; if( av = GetOptions(MYNAME) ) { v = *av; } /* * Copy to local variables */ BGUIBase = PPTBase->lb_BGUI; IntuitionBase = (struct IntuitionBase *)PPTBase->lb_Intuition; DOSBase = PPTBase->lb_DOS; SysBase = PPTBase->lb_Sys; /* * Parse AREXX message, which has to exist. * BUG: If necessary, should wait for D&D from the main window. * BUG: Should make sanity checks! */ args = (ULONG *) TagData( PPTX_RexxArgs, tags ); if( args ) { /* WITH */ if( args[0] ) { with = FindFrame( (ID) PEEKL(args[0]) ); if(!with) { SetErrorMsg(frame,"Unknown frame ID for WITH parameter"); return NULL; } } /* TOP */ if( args[1] ) { gfr.y = (WORD) PEEKL(args[1]); reallyrexx = TRUE; } /* LEFT */ if( args[2] ) { gfr.x = (WORD) PEEKL(args[2]); reallyrexx = TRUE; } /* METHOD */ if( args[3] ) { int i; for( i = 0; method_labels[i]; i++ ) { if(stricmp( method_labels[i], (char *)args[3] ) == 0 ) { v.method = i; reallyrexx = TRUE; break; } } } /* RATIO */ if( v.method == Mix ) { if( args[4] ) { v.ratio = PEEKL( args[4] ); } else { SetErrorCode(frame,PERR_INVALIDARGS); } } /* TILE */ if( args[5] ) { v.tile = TRUE; } else { v.tile = FALSE; } } else { SetErrorMsg(frame,"Image compositing can be used with Drag&Drop (or REXX) only"); return NULL; } /* * Make some sanity checks */ if( frame->pix->width < with->pix->width || frame->pix->height < with->pix->height ) { SetErrorMsg(frame,"You cannot composite a larger picture on a smaller one!"); return NULL; } fc = frame->pix->colorspace; wc = with->pix->colorspace; if( ! (wc == fc || (fc == CS_ARGB && wc == CS_RGB) || (fc == CS_RGB && wc == CS_ARGB ))) { SetErrorMsg(frame, "Only images of the same color space can be composited"); return NULL; } gfr.dim.Left = 0; gfr.dim.Top = 0; gfr.dim.Height = with->pix->height; gfr.dim.Width = with->pix->width; /* * Open window and start parsing */ if( reallyrexx == FALSE ) { if( GimmeWindow(frame, with, PPTBase) ) { ULONG sigmask, gimask = 0L; GetAttr( WINDOW_SigMask, Win, &sigmask ); StartInput(frame, GINP_FIXED_RECT, (struct PPTMessage *) &gfr); gimask = (1 << PPTBase->mport->mp_SigBit); while( !quit ) { sig = Wait( sigmask|gimask|SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_F ); if( sig & SIGBREAKF_CTRL_C ) { D(bug("BREAK!\n")); SetErrorCode( frame, PERR_BREAK ); quit = TRUE; break; } if( sig & SIGBREAKF_CTRL_F ) { WindowToFront(win); ActivateWindow(win); } if( sig & gimask ) { struct gFixRectMessage *pmsg; if(pmsg = (struct gFixRectMessage *)GetMsg( PPTBase->mport )) { if( pmsg->msg.code == PPTMSG_FIXED_RECT ) { D(bug("User picked a point @ (%d,%d)\n",pmsg->x, pmsg->y)); gfr.x = pmsg->x; gfr.y = pmsg->y; // SetGadgetAttrs( ( struct Gadget *)OKButton, win, NULL, GA_Disabled, FALSE ); } ReplyMsg( (struct Message *)pmsg ); } } if( sig & sigmask ) { while( (rc = HandleEvent( Win )) != WMHI_NOMORE ) { ULONG t; switch(rc) { case GID_OK: GetAttr( CYC_Active, Method, (ULONG *)&v.method ); GetAttr( SLIDER_Level, Ratio, &v.ratio ); /* * Save the window attributes for later retrieval. */ GetAttr( WINDOW_Bounds, Win, (ULONG *) &v.bounds ); GetAttr( GA_Selected, Tile, &t ); StopInput( frame ); v.tile = (BOOL) t; WindowClose(Win); newframe = DoComposite( frame, with, &gfr, v.method, (WORD) v.ratio, v.tile, PPTBase ); quit = TRUE; break; case GID_CANCEL: quit = TRUE; StopInput( frame ); break; } } } } } } else { /* gfr is already set up */ newframe = DoComposite( frame, with, &gfr, v.method, (WORD) v.ratio, v.tile, PPTBase ); } if(Win) DisposeObject(Win); if( newframe ) { PutOptions( MYNAME, &v, sizeof(struct Values) ); } D(bug("Returning %08X...\n",newframe)); return newframe; }