/***** * Name: _PLC_GIF_ScanlineProc * Return Type: void * Description: GZF scanline processor (decompresses data and orders it) * In: * plc: current PLC * Returns: * nothing. *****/ void _PLC_GIF_ScanlineProc(PLC *plc) { Byte *input = NULL; PLCImageGIF *gif; Boolean done = False; int bytes_avail; _XmHTMLDebug(15, ("plc.c: _PLC_GIF_ScanlineProc for %s\n", plc->url)); gif = &(plc->object->plc_gif_image); /***** * We can choose between two types of LZW decoders: the internal one or * an externally installed progressive decoder. * The internal decoder is fairly efficient for direct gif loading, but is * *HUGELY* slow for progressive gif loading: it forks of uncompress (or * gzip) each time LZWStreamUncompress is called. Therefore we collect * all data and call the internal decoder when all image data has been * received. * When an external gif decoder has been installed, we just proceed in the * same way as with the GZF scanline procedure: decode a chunk of data * each time and allow it to be transfered to the display. *****/ if(gif->external_codec == False) { int len; Boolean have_all = False; bytes_avail = plc->left; #ifndef PLC_WORKPROCS do { #endif /* !PLC_WORKPROCS */ /***** * get a new block of compressed data. This will automatically make * a new request for input data when there isn't enough data left * in the current input buffer. *****/ if((len = _PLCGetDataBlock(plc, gif->gbuf)) != 0) { /* store block size */ gif->ib.buffer[gif->ib.size++] = (Byte)len; /* append newly received data */ (void)memcpy(gif->ib.buffer + gif->ib.size, gif->gbuf, len); /* new buffer size */ gif->ib.size += len; /* bytes left in current buffer (+1 for block header) */ bytes_avail -= (len + 1); /* prevent image transfer function from doing anything */ gif->prev_pos = gif->data_pos = 0; } else { if(plc->plc_status == PLC_SUSPEND || plc->plc_status == PLC_ABORT) return; /* * if plc_status == PLC_ACTIVE, we have a zero data block which * indicates the raster data end. For now we just consider this * as the end signal and start decoding the raster data. * For gif animations this would be the place to move to the * next frame. */ have_all = True; /* plug in a zero length data block and GIF terminator */ gif->ib.buffer[gif->ib.size++] = (Byte)0; gif->ib.buffer[gif->ib.size++] = (Byte)1; gif->ib.buffer[gif->ib.size++] = (Byte)';'; } #ifndef PLC_WORKPROCS } /* This test will be false if we made a new data request */ while(bytes_avail == plc->left && have_all == False); #endif /* !PLC_WORKPROCS */ /* we have got all image data, now decode it */ if(have_all) { /* rewind image buffer */ gif->ib.next = 0; /* now (re-)initialize the stream object */ if((LZWStreamInit(gif->lstream)) <= 0) { /* this is an error */ _XmHTMLWarning(__WFUNC__(plc->object->plc_any_image.owner, "_PLC_GIF_ScanlineProc"), gif->lstream->err_msg); plc->plc_status = PLC_ABORT; return; } /* convert data */ LZWStreamConvert(gif->lstream); /* get uncompressed data */ if((input = LZWStreamUncompress(gif->lstream, (int*)&gif->byte_count)) == NULL) { _XmHTMLWarning(__WFUNC__(plc->object->plc_any_image.owner, "_PLC_GIF_ScanlineProc"), gif->lstream->err_msg); /* rather fatal... */ _XmHTMLWarning(__WFUNC__(plc->object->plc_any_image.owner, "_PLC_GIF_ScanlineProc"), XMHTML_MSG_114, plc->url); plc->plc_status = PLC_ABORT; return; } /* convert input data to raw image data */ (void)DoImage((PLCImage*)gif, input); /* free input buffer */ free(input); /* we are finished here */ plc->obj_funcs_complete = True; } } else { /***** * External GIF decoder installed, proceeds in the same way as the * GZF decoder, except that now the external decoder is called * instead of the zlib routines. *****/ XmHTMLGIFStream *gifstream = gif->gstream; int err; bytes_avail = plc->left; #ifndef PLC_WORKPROCS do { #endif /* !PLC_WORKPROCS */ /***** * get a new block of compressed data. This will automatically make * a new request for input data when there isn't enough data left * in the current input buffer. *****/ if((gifstream->avail_in = _PLCGetDataBlock(plc, gif->gbuf)) == 0) { if(plc->plc_status == PLC_SUSPEND || plc->plc_status == PLC_ABORT) return; /* * if plc_status == PLC_ACTIVE, we have a zero data block which * indicates the raster data end. Put in a 0 length data * block, the gif terminator, set the gifstream state so the * caller knows to wrap things up and proceed. */ gif->gbuf[0] = (Byte)0; gif->gbuf[1] = (Byte)1; gif->gbuf[2] = (Byte)';'; gifstream->avail_in = 3; gifstream->state = GIF_STREAM_FINAL; } gifstream->next_in = gif->gbuf; /* bytes left in current buffer (+1 for block header) */ bytes_avail -= (gifstream->avail_in + 1); /* adjust output buffer */ gifstream->next_out = gif->buffer + gifstream->total_out; gifstream->avail_out = gif->buf_size - gifstream->total_out; /* uncompress it */ err = gif->inflate(gifstream); /* check return value */ if(err != GIF_STREAM_OK && err != GIF_STREAM_END) { _XmHTMLWarning(__WFUNC__(NULL, "_PLC_GIF_ScanlineProc"), XMHTML_MSG_115, plc->url, gifstream->msg ? gifstream->msg : "(unknown error)"); plc->plc_status = PLC_ABORT; return; } /* this many uncompressed bytes available now */ gif->byte_count = gifstream->total_out; /* convert input data to raw image data */ done = DoImage((PLCImage*)gif, gif->buffer); /* and break if inflate has finished uncompressing our data. */ if(err == GIF_STREAM_END || done == True) plc->obj_funcs_complete = True; #ifndef PLC_WORKPROCS } /* This test will be false if we made a new data request */ while(bytes_avail == plc->left); #endif /* !PLC_WORKPROCS */ } }
/***** * Name: _PLC_GZF_ScanlineProc * Return Type: void * Description: GZF scanline processor (decompresses data and orders it) * In: * plc: current PLC * Returns: * nothing. *****/ void _PLC_GZF_ScanlineProc(PLC *plc) { int err, bytes_avail; PLCImageGZF *gzf; Boolean done = False; _XmHTMLDebug(15, ("plc.c: _PLC_GZF_ScanlineProc for %s\n", plc->url)); gzf = &(plc->object->plc_gzf_image); /* bytes left in current input buffer */ bytes_avail = plc->left; #ifndef PLC_WORKPROCS do { #endif /* !PLC_WORKPROCS */ /***** * get a new block of compressed data. This will automatically make * a new request for input data when there isn't enough data left * in the current input buffer. *****/ if((gzf->zstream.avail_in = _PLCGetDataBlock(plc, gzf->zbuf)) == 0) { /* * if plc_status == PLC_ACTIVE, we have a zero data block which * indicates the raster data end. For now we just consider this * as the end signal and return without further processing. * For gif animations this would be the place to move to the next * frame. */ return; /* aborted, date ended or plc suspended */ } gzf->zstream.next_in = gzf->zbuf; /* bytes left in current buffer (+1 for block header) */ bytes_avail -= (gzf->zstream.avail_in + 1); /* adjust output buffer */ gzf->zstream.next_out = gzf->buffer + gzf->zstream.total_out; gzf->zstream.avail_out = gzf->buf_size - gzf->zstream.total_out; /* uncompress it */ err = inflate(&gzf->zstream, Z_PARTIAL_FLUSH); /* check return value */ if(err != Z_OK && err != Z_STREAM_END) { _XmHTMLWarning(__WFUNC__(NULL, "_PLC_GZF_ScanlineProc"), XMHTML_MSG_108, plc->url, "", gzf->zstream.msg); plc->plc_status = PLC_ABORT; return; } /* this many uncompressed bytes available now */ gzf->byte_count = gzf->zstream.total_out; /* convert input data to raw image data */ done = DoImage((PLCImage*)gzf, gzf->buffer); /* and break if inflate has finished uncompressing our data. */ if(err == Z_STREAM_END || done == True) plc->obj_funcs_complete = True; #ifndef PLC_WORKPROCS } /* This test will be false if we made a new data request */ while(bytes_avail == plc->left); #endif /* !PLC_WORKPROCS */ }
void CLuaUi::Tick() { if (!m_Used) return; if (m_Type == LUAUIBUTTON) { int state = DoButton_Menu(&m_Id, m_pText, m_Checked, &m_Rect, m_Corners, m_Color); if (state != 0) { if (!m_pLuaFile->FunctionExist(m_pCallback)) return; m_pLuaFile->FunctionPrepare(m_pCallback); m_pLuaFile->PushInteger(state); m_pLuaFile->PushInteger(m_Id); m_pLuaFile->FunctionExec(); } } else if(m_Type == LUAUIEDITBOX) { DoEditBox(&m_Id, &m_Rect, m_pText, sizeof(m_pText), m_FontSize, &m_Offset, m_Hidden, m_Corners, m_Color); } else if(m_Type == LUAUILABEL) { CUIRect *pRect = &m_Rect; CUIRect Temp; pRect->HMargin(pRect->h>=20.0f?2.0f:1.0f, &Temp); m_pClient->TextRender()->TextColor(m_Color.r, m_Color.g, m_Color.b, m_Color.a); if (m_Align == -1) m_pClient->UI()->DoLabelScaled(&Temp, m_pText, m_FontSize*ms_FontmodHeight, m_Align, Temp.w); else m_pClient->UI()->DoLabelScaled(&Temp, m_pText, m_FontSize*ms_FontmodHeight, m_Align); m_pClient->TextRender()->TextColor(1, 1, 1, 1); } else if(m_Type == LUAUIRECT) { CUIRect *pRect = &m_Rect; m_pClient->RenderTools()->DrawUIRect(pRect, m_Color, m_Corners, m_Rounding); } else if(m_Type == LUAUIIMAGE) { CUIRect *pRect = &m_Rect; int state = DoImage(&m_Id, m_TextureID, m_SpriteID, pRect); if (state != 0) { if (!m_pLuaFile->FunctionExist(m_pCallback)) return; m_pLuaFile->FunctionPrepare(m_pCallback); m_pLuaFile->PushInteger(state); m_pLuaFile->PushInteger(m_Id); m_pLuaFile->FunctionExec(); } } else if(m_Type == LUAUIIMAGEEX) { CUIRect *pRect = &m_Rect; int state = DoImageEx(&m_Id, m_TextureID, pRect, m_ClipX1, m_ClipY1, m_ClipX2, m_ClipY2); if (state != 0) { if (!m_pLuaFile->FunctionExist(m_pCallback)) return; m_pLuaFile->FunctionPrepare(m_pCallback); m_pLuaFile->PushInteger(state); m_pLuaFile->PushInteger(m_Id); m_pLuaFile->FunctionExec(); } } else if(m_Type == LUAUILINE) { m_pClient->Graphics()->TextureSet(-1); m_pClient->Graphics()->BlendNormal(); m_pClient->Graphics()->LinesBegin(); m_pClient->Graphics()->SetColor(m_Color.r, m_Color.g, m_Color.b, m_Color.a); IGraphics::CLineItem Line; Line = IGraphics::CLineItem(m_Rect.x, m_Rect.y, m_Rect.w, m_Rect.h); m_pClient->Graphics()->LinesDraw(&Line, 1); m_pClient->Graphics()->LinesEnd(); } else if(m_Type == LUAUISLIDER) { float NewValue = 0; if (m_Direction == 0) { NewValue = DoScrollbarH(&m_Id, &m_Rect, m_Value, m_Color); } else { NewValue = DoScrollbarV(&m_Id, &m_Rect, m_Value, m_Color); } if (m_Value != NewValue) { m_Value = NewValue; if (!m_pLuaFile->FunctionExist(m_pCallback)) return; m_pLuaFile->FunctionPrepare(m_pCallback); m_pLuaFile->PushFloat(m_Value); m_pLuaFile->PushInteger(m_Id); m_pLuaFile->FunctionExec(); } } }