static IPTR mLampCleanup(struct IClass *cl,Object *obj,struct MUIP_Setup *msg)
{
struct lampData *data = INST_DATA(cl,obj);
if(isFlagSet(data->flags, FLG_LampSetup))
{
MUI_ReleasePen(muiRenderInfo(obj),data->enabled);
MUI_ReleasePen(muiRenderInfo(obj),data->disabled);
MUI_ReleasePen(muiRenderInfo(obj),data->detail);
CLEAR_FLAG(data->flags, FLG_LampSetup);
}
return DoSuperMethodA(cl,obj,(APTR)msg);
}
IPTR Pendisplay__MUIM_Cleanup(struct IClass *cl, Object *obj, struct MUIP_Cleanup *msg)
{
struct Pendisplay_DATA *data = INST_DATA(cl,obj);
if (data->pen != -1)
{
MUI_ReleasePen(muiRenderInfo(obj), data->pen);
data->pen = -1;
}
return DoSuperMethodA(cl, obj, (Msg)msg);
}
IPTR Pendisplay__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
{
struct Pendisplay_DATA *data = INST_DATA(cl,obj);
if (!(DoSuperMethodA(cl, obj, (Msg)msg))) return 0;
if (!data->refobj)
{
data->pen = MUI_ObtainPen(muiRenderInfo(obj), &data->penspec, 0);
}
return 1;
}
IPTR SMEditor__MUIM_PrefsEditor_Use
(
Class *CLASS, Object *self, Msg message
)
{
#warning "FIXME: Closing the window here only works because we're lucky "
#warning " and nothing needs to access anything that is put in the "
#warning " RenderInfo structure, which gets deallocated when closing"
#warning " the window. This needs to be fixed directly in the "
#warning " PrefsEditor class. "
if (muiRenderInfo(self) && _win(self))
set(_win(self), MUIA_Window_Open, FALSE);
return DoSuperMethodA(CLASS, self, message);
}
IPTR Numericbutton__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
{
struct Numericbutton_DATA *data = INST_DATA(cl, obj);
// const struct ZuneFrameGfx *knob_frame;
IPTR retval;
retval = DoSuperMethodA(cl, obj, (Msg)msg);
if (retval)
{
//knob_frame = zune_zframe_get(obj, &muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_Knob]);
data->knob_bg = zune_imspec_setup(MUII_ButtonBack, muiRenderInfo(obj));
DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
data->needs_to_recalculate_sizes = TRUE;
}
return retval;
}
static IPTR mLampSetup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
{
struct lampData *data = INST_DATA(cl,obj);
if (!DoSuperMethodA(cl,obj,(APTR)msg)) return FALSE;
if (MUIMasterBase->lib_Version<20)
{
data->enabled = MUI_ObtainPen(muiRenderInfo(obj),(APTR)"r00000000,ffffffff,00000000",0);
data->disabled = MUI_ObtainPen(muiRenderInfo(obj),(APTR)"rffffffff,00000000,00000000",0);
data->detail = MUI_ObtainPen(muiRenderInfo(obj),(APTR)"r00000000,00000000,00000000",0);
}
else
{
data->enabled = MUI_ObtainPen(muiRenderInfo(obj),(APTR)"r02ff00",0);
data->disabled = MUI_ObtainPen(muiRenderInfo(obj),(APTR)"rff0000",0);
data->detail = MUI_ObtainPen(muiRenderInfo(obj),(APTR)"r000000",0);
}
SET_FLAG(data->flags, FLG_LampSetup);
return TRUE;
}
IPTR Pendisplay__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Pendisplay_DATA *data;
const struct TagItem *tags;
struct TagItem *tag;
BOOL newcol = FALSE;
IPTR retval;
data = INST_DATA(cl, obj);
for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Pendisplay_Reference:
if (data->refobj)
{
DoMethod(data->refobj, MUIM_KillNotifyObj, MUIA_Pendisplay_Spec, (IPTR)obj);
}
data->refobj = (Object *)tag->ti_Data;
if (data->refobj)
{
DoMethod(data->refobj, MUIM_Notify, MUIA_Pendisplay_Spec, MUIV_EveryTime,
(IPTR)obj, 3, MUIM_Set, MUIA_Pendisplay_Spec, MUIV_TriggerValue);
}
newcol = TRUE;
break;
case MUIA_Pendisplay_RGBcolor:
{
struct MUI_RGBcolor *rgb = (struct MUI_RGBcolor *)tag->ti_Data;
snprintf(data->penspec.ps_buf, sizeof(data->penspec.ps_buf),
"%lc%08lx,%08lx,%08lx", (LONG)PST_RGB, rgb->red, rgb->green, rgb->blue);
}
newcol = TRUE;
break;
case MUIA_Pendisplay_Spec:
if (tag->ti_Data)
{
data->penspec = *(struct MUI_PenSpec *)tag->ti_Data;
newcol = TRUE;
}
break;
}
}
retval = DoSuperMethodA(cl, obj, (Msg)msg);
if (newcol && (_flags(obj) & MADF_SETUP))
{
if (data->pen != -1)
{
MUI_ReleasePen(muiRenderInfo(obj), data->pen);
data->pen = -1;
}
if (!data->refobj)
{
data->pen = MUI_ObtainPen(muiRenderInfo(obj), &data->penspec, 0);
}
MUI_Redraw(obj, MADF_DRAWUPDATE);
}
return retval;
}
LONG PrintLine(LONG x, struct line_node *line, LONG line_nr, BOOL doublebuffer, struct InstData *data)
{
STRPTR text = line->line.Contents;
LONG length;
struct RastPort *rp = &data->doublerp;
ENTER();
length = LineCharsWidth(text+x, data);
if(doublebuffer == FALSE)
rp = &data->copyrp;
if((line_nr > 0) && (data->update) && !(data->flags & FLG_Quiet) && data->rport != NULL && data->shown == TRUE)
{
LONG c_length = length;
LONG startx = 0, stopx = 0;
LONG starty = 0, xoffset = ((data->height-rp->TxBaseline+1)>>1)+1;
LONG flow = 0;
UWORD *styles = line->line.Styles;
UWORD *colors = line->line.Colors;
struct marking block;
BOOL cursor = FALSE;
if(line->line.Color && x == 0 && line->line.Length == 1)
line->line.Color = FALSE;
if(doublebuffer == FALSE)
{
starty = data->ypos+(data->height * (line_nr-1));
xoffset = data->xpos;
}
flow = FlowSpace(line->line.Flow, text+x, data);
Move(rp, xoffset+flow, starty+rp->TxBaseline);
if(Enabled(data))
{
struct line_node *blkline;
NiceBlock(&data->blockinfo, &block);
blkline = block.startline->next;
if(block.startline == block.stopline)
{
if(block.startline == line)
{
startx = block.startx;
stopx = block.stopx;
}
}
else
{
if(block.startline == line)
{
startx = block.startx;
stopx = line->line.Length;
}
else
{
if(block.stopline == line)
{
stopx = block.stopx;
}
else
{
while((blkline != block.stopline) && (!stopx))
{
if(blkline == line)
{
stopx = line->line.Length;
}
blkline = blkline->next;
}
}
}
}
}
{
UWORD blockstart = 0;
UWORD blockwidth = 0;
struct RastPort *old = muiRenderInfo(data->object)->mri_RastPort;
if(startx < x+c_length && stopx > x)
{
if(startx > x)
blockstart = TextLength(&data->tmprp, text+x, startx-x);
else
startx = x;
blockwidth = ((stopx >= c_length+x) ? data->innerwidth-(blockstart+flow) : TextLength(&data->tmprp, text+startx, stopx-startx));
}
else if(!(data->flags & (FLG_ReadOnly | FLG_Ghosted)) &&
line == data->actualline && data->CPos_X >= x &&
data->CPos_X < x+c_length && !Enabled(data) &&
(data->flags & FLG_Active || data->inactiveCursor == TRUE))
{
cursor = TRUE;
blockstart = TextLength(&data->tmprp, text+x, data->CPos_X-x);
// calculate the cursor width
// if it is set to 6 then we should find out how the width of the current char is
if(data->CursorWidth == 6)
blockwidth = TextLength(&data->tmprp, (*(text+data->CPos_X) < ' ') ? (char *)" " : (char *)(text+data->CPos_X), 1);
else
blockwidth = data->CursorWidth;
}
SetDrMd(rp, JAM1);
muiRenderInfo(data->object)->mri_RastPort = rp;
// clear the background first
DoMethod(data->object, MUIM_DrawBackground, xoffset, starty,
flow+blockstart, data->height,
(data->flags & FLG_InVGrp) ? 0 : data->xpos,
(data->flags & FLG_InVGrp) ? data->height*(data->visual_y+line_nr-2) : data->realypos+data->height * (data->visual_y+line_nr-2),
0);
if(blockwidth)
{
ULONG color;
// in case the gadget is in inactive state we use a different background
// color for our selected area
if((data->flags & FLG_Active) == 0 && (data->flags & FLG_Activated) == 0 &&
(data->flags & FLG_ActiveOnClick) != 0)
{
color = data->inactivecolor;
}
else
color = data->markedcolor;
// if selectmode == 2 then a whole line should be drawn as being marked, so
// we have to start at xoffset instead of xoffset+flow+blockstart.
// Please note that the second part of the following "empiric" evaluation should
// prevent that centered or right aligned lines are not correctly marked right
// from the beginning of the line. However, it seems to be not cover 100% of all different
// cases so that the evaluation if a line should be completely marked should be probably
// moved elsewhere in future.
if(data->selectmode == 2 ||
(flow && data->selectmode != 1 && startx-x == 0 && cursor == FALSE &&
((data->blockinfo.startline != data->blockinfo.stopline) || x > 0)))
{
SetAPen(rp, color);
RectFill(rp, xoffset, starty, xoffset+flow+blockwidth-1, starty+data->height-1);
}
else
{
SetAPen(rp, cursor ? data->cursorcolor : color);
RectFill(rp, xoffset+flow+blockstart, starty, xoffset+flow+blockstart+blockwidth-1, starty+data->height-1);
// if the gadget is in inactive state we just draw a skeleton cursor instead
if(cursor == TRUE &&
(data->flags & FLG_Active) == 0 && (data->flags & FLG_Activated) == 0)
{
DoMethod(data->object, MUIM_DrawBackground, xoffset+flow+blockstart+1, starty+1,
blockwidth-2, data->height-2,
(data->flags & FLG_InVGrp) ? 0 : data->xpos,
(data->flags & FLG_InVGrp) ? data->height*(data->visual_y+line_nr-2) : data->realypos+data->height * (data->visual_y+line_nr-2),
0);
}
}
}
{
LONG x_start = xoffset+blockstart+blockwidth,
y_start = starty,
x_width = data->innerwidth-(blockstart+blockwidth),
y_width = data->height,
x_ptrn = blockstart+blockwidth,
y_ptrn = data->height*(data->visual_y+line_nr-2);
if(blockwidth)
{
x_start += flow;
x_width -= flow;
x_ptrn += flow;
}
if(!(data->flags & FLG_InVGrp))
{
x_ptrn += data->xpos;
y_ptrn += data->realypos;
}
DoMethod(data->object, MUIM_DrawBackground, x_start, y_start, x_width, y_width, x_ptrn, y_ptrn);
}
muiRenderInfo(data->object)->mri_RastPort = old;
}
if(doublebuffer == FALSE)
AddClipping(data);
SetAPen(rp, (line->line.Color ? data->highlightcolor : data->textcolor));
while(c_length)
{
LONG p_length = c_length;
SetSoftStyle(rp, convert(GetStyle(x, line)), AskSoftStyle(rp));
if(styles)
{
while(*styles-1 <= x)
{
styles += 2;
}
if(*styles-x-1 < p_length)
{
p_length = *styles-x-1;
}
}
if(colors)
{
while(*colors-1 <= x)
{
SetAPen(rp, ConvertPen(*(colors+1), line->line.Color, data));
colors += 2;
}
if(*colors-x-1 < p_length)
{
p_length = *colors-x-1;
}
}
/* if(stopx)
{
if((startx > x) && (startx-x < p_length))
{
p_length = startx-x;
SetAPen(rp, 3);
}
else
{
if((stopx > x) && (stopx-x < p_length))
{
p_length = stopx-x;
SetAPen(rp, 4);
}
else
SetAPen(rp, (line->color ? data->highlightcolor : data->textcolor));
}
}
*/
if(text[x+p_length-1] < ' ')
Text(rp, text+x, p_length-1);
else
Text(rp, text+x, p_length);
x += p_length;
c_length -= p_length;
}
SetSoftStyle(rp, FS_NORMAL, AskSoftStyle(rp));
if(line->line.Separator)
{
WORD LeftX, LeftWidth,
RightX, RightWidth,
Y, Height;
LeftX = xoffset;
LeftWidth = flow-3;
RightX = rp->cp_x+3;
RightWidth = xoffset+data->innerwidth - RightX;
Y = starty;
Height = (line->line.Separator & LNSF_Thick) ? 2 : 1;
if(line->line.Separator & LNSF_Middle)
Y += (data->height/2)-Height;
else
{
if(line->line.Separator & LNSF_Bottom)
Y += data->height-(2*Height);
}
if(line->line.Separator & LNSF_StrikeThru || line->line.Length == 1)
{
LeftWidth = data->innerwidth;
}
else
{
DrawSeparator(rp, RightX, Y, RightWidth, Height, data);
}
DrawSeparator(rp, LeftX, Y, LeftWidth, Height, data);
}
if(data->flags & FLG_Ghosted)
{
UWORD *oldPattern = (UWORD *)rp->AreaPtrn;
UBYTE oldSize = rp->AreaPtSz;
UWORD newPattern[] = {0x1111, 0x4444};
if(doublebuffer == TRUE)
{
ULONG ptrn1 = 0x11111111;
ULONG ptrn2 = 0x44444444;
ptrn1 = ptrn1>>((data->xpos-xoffset)%16);
ptrn2 = ptrn2>>((data->xpos-xoffset)%16);
if((data->height*(data->visual_y+line_nr-2))%2 == 0)
{
newPattern[0] = ptrn2;
newPattern[1] = ptrn1;
}
else
{
newPattern[0] = ptrn1;
newPattern[1] = ptrn2;
}
}
static BOOL MakePopupWin(Object *obj, struct Numericbutton_DATA *data)
{
const struct ZuneFrameGfx *zframe;
struct RastPort *rp, *saverp;
LONG winx, winy, winw, winh;
LONG framew, frameh;
LONG min, max;
zframe = zune_zframe_get_with_state(obj, &muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_Slider],
muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_Slider].state);
data->pop_innerx = zframe->ileft;
data->pop_innery = zframe->itop;
data->knob_width = data->max_text_width + 4;
data->knob_height = data->text_height + 2;
framew = data->pop_innerx + zframe->iright;
frameh = data->pop_innery + zframe->ibottom;
longget(obj, MUIA_Numeric_Min, &min);
longget(obj, MUIA_Numeric_Max, &max);
winw = max - min + data->knob_width + framew;
winh = data->knob_height + frameh;
if (winw > _screen(obj)->Width)
{
winw = _screen(obj)->Width;
}
if ((winw < data->knob_width + framew) || (winh > _screen(obj)->Height))
{
return FALSE;
}
data->pop_innerw = winw - framew;
data->pop_innerh = winh - frameh;
data->knob_left = DoMethod(obj, MUIM_Numeric_ValueToScale, 0, data->pop_innerw - data->knob_width);
winx = _window(obj)->LeftEdge + _mleft(obj) -
data->pop_innerx - 2 -
data->knob_left;
winy = _window(obj)->TopEdge + _mtop(obj) - 1-
data->pop_innery;
data->popwin = OpenWindowTags(NULL, WA_CustomScreen, (IPTR)_screen(obj),
WA_Left, winx,
WA_Top, winy,
WA_Width, winw,
WA_Height, winh,
WA_AutoAdjust, TRUE,
WA_Borderless, TRUE,
WA_Activate, FALSE,
WA_BackFill, (IPTR)LAYERS_NOBACKFILL,
TAG_DONE);
if (!data->popwin)
{
return FALSE;
}
rp = data->popwin->RPort;
saverp = _rp(obj);
_rp(obj) = rp;
zframe->draw(zframe->customframe, muiRenderInfo(obj), 0, 0, winw, winh, 0, 0, winw, winh);
DrawKnob(obj, data, TRUE);
_rp(obj) = saverp;
return TRUE;
}
static void DrawKnob(Object *obj, struct Numericbutton_DATA *data, BOOL force)
{
struct RastPort *rp, *saverp;
LONG x, val, pixeloffset, textlen, pixellen;
STRPTR text;
pixeloffset = data->popwin->MouseX - data->pop_innerx - 2 - data->knob_clickoffset_x;
val = DoMethod(obj, MUIM_Numeric_ScaleToValue, 0,
data->pop_innerw - data->knob_width, pixeloffset);
data->knob_left = data->pop_innerx + pixeloffset;
data->knob_top = data->pop_innery;
data->knob_val = val;
if (!force && (data->knob_left == data->knob_prev_left))
{
return;
}
data->knob_prev_left = data->knob_left;
if (data->knob_left < data->pop_innerx)
{
data->knob_left = data->pop_innerx;
}
else if (data->knob_left > data->pop_innerx + data->pop_innerw - data->knob_width)
{
data->knob_left = data->pop_innerx + data->pop_innerw - data->knob_width;
}
saverp = _rp(obj);
_rp(obj) = rp = data->popwin->RPort;
SetABPenDrMd(rp, _pens(obj)[MPEN_SHINE], 0, JAM1);
RectFill(rp, data->knob_left, data->knob_top,
data->knob_left, data->knob_top + data->knob_height - 1);
RectFill(rp, data->knob_left + 1, data->knob_top,
data->knob_left + data->knob_width - 1, data->knob_top);
SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
RectFill(rp, data->knob_left + data->knob_width - 1, data->knob_top + 1,
data->knob_left + data->knob_width - 1, data->knob_top + data->knob_height - 1);
RectFill(rp, data->knob_left + 1, data->knob_top + data->knob_height - 1,
data->knob_left + data->knob_width - 2, data->knob_top + data->knob_height - 1);
if (data->knob_bg)
{
#warning "Ugly hack?"
struct IBox old_mad_Box = muiAreaData(obj)->mad_Box;
muiAreaData(obj)->mad_Box.Left = data->knob_left + 1;
muiAreaData(obj)->mad_Box.Top = data->knob_top + 1;
muiAreaData(obj)->mad_Box.Width = data->knob_width - 2;
muiAreaData(obj)->mad_Box.Height = data->knob_height - 2;
zune_imspec_draw(data->knob_bg, muiRenderInfo(obj),
data->knob_left + 1,
data->knob_top + 1,
data->knob_width - 2,
data->knob_height - 2,
0,
0,
0);
muiAreaData(obj)->mad_Box = old_mad_Box;
}
else
{
SetAPen(rp, _pens(obj)[MPEN_BACKGROUND]);
RectFill(rp, data->knob_left + 1, data->knob_top + 1,
data->knob_left + data->knob_width - 2,
data->knob_top + data->knob_height - 2);
}
SetFont(rp, _font(obj));
text = (STRPTR)DoMethod(obj, MUIM_Numeric_Stringify, val);
textlen = strlen(text);
pixellen = TextLength(_rp(obj), text, textlen);
SetAPen(rp, _pens(obj)[MPEN_TEXT]);
Move(rp, data->knob_left + 2 + (data->knob_width - 4 - pixellen) / 2,
data->knob_top + 1 + rp->TxBaseline);
Text(rp, text, textlen);
SetAPen(rp, _pens(obj)[MPEN_BACKGROUND]);
if (data->knob_left - 1 >= data->pop_innerx)
{
RectFill(rp, data->pop_innerx, data->pop_innery,
data->knob_left - 1, data->pop_innery + data->pop_innerh - 1);
}
x = data->knob_left + data->knob_width;
if (x <= data->pop_innerx + data->pop_innerw - 1)
{
RectFill(rp, x, data->pop_innery,
data->pop_innerx + data->pop_innerw - 1,
data->pop_innery + data->pop_innerh - 1);
}
_rp(obj) = saverp;
}
