static JSObject * reflect_anchor_array(MochaDecoder *decoder, JSClass *clasp, JSNative constructor, JSObject *document) { JSContext *cx; JSObject *obj, *prototype; JSObjectArray *array; JSDocument *doc; cx = decoder->js_context; doc = JS_GetPrivate(cx, document); if (!doc) return NULL; prototype = JS_InitClass(cx, decoder->window_object, NULL, clasp, constructor, 0, anchor_array_props, NULL, NULL, NULL); if (!prototype) return NULL; array = JS_malloc(cx, sizeof *array); if (!array) return NULL; XP_BZERO(array, sizeof *array); obj = JS_NewObject(cx, clasp, prototype, document); if (!obj || !JS_SetPrivate(cx, obj, array)) { JS_free(cx, array); return NULL; } array->decoder = HOLD_BACK_COUNT(decoder); array->layer_id = doc->layer_id; return obj; }
JSObject* lm_DefineComponents(MochaDecoder *decoder) { JSObject *obj; JSComponentArray *array; JSContext *cx = decoder->js_context; JSPreDefComponent def_comps; JSComponent *component; jsint slot; obj = decoder->components; if (obj) return obj; array = JS_malloc(cx, sizeof(JSComponentArray)); if (!array) return NULL; XP_BZERO(array, sizeof *array); obj = JS_NewObject(cx, &lm_component_array_class, NULL, decoder->window_object); if (!obj || !JS_SetPrivate(cx, obj, array)) { JS_free(cx, array); return NULL; } if (!JS_DefineProperties(cx, obj, componentarray_props)) return NULL; array->decoder = HOLD_BACK_COUNT(decoder); array->obj = obj; /* Components can be added dynamically but some are predefined */ slot = 0; array->length = 0; def_comps = predef_components[slot]; while (def_comps.name) { component = JS_malloc(cx, sizeof(JSComponent)); if (!component) return NULL; if (ET_moz_VerifyComponentFunction(def_comps.func, &(component->active_callback), &(component->startup_callback))) { componentarray_create_component(cx, array, component, def_comps.name, array->length); } else { /*Component call failed somewhere.*/ JS_free(cx, component); } def_comps = predef_components[++slot]; } return obj; }
JSObject * lm_DefineLocation(MochaDecoder *decoder) { JSObject *obj; JSContext *cx; JSURL *url; obj = decoder->location; if (obj) return obj; cx = decoder->js_context; url = JS_malloc(cx, sizeof *url); if (!url) return NULL; XP_BZERO(url, sizeof *url); obj = JS_InitClass(cx, decoder->window_object, NULL, &lm_location_class, Location, 0, url_props, loc_methods, NULL, NULL); if (!obj || !JS_SetPrivate(cx, obj, url)) { JS_free(cx, url); return NULL; } /* XXX common subroutine this and above with lm_NewURL */ if (!JS_AddNamedRoot(cx, &url->href, "loc.text")) return NULL; if (!JS_AddNamedRoot(cx, &url->target, "loc.target")) return NULL; if (!JS_AddNamedRoot(cx, &url->text, "loc.text")) return NULL; if (!JS_DefineProperty(cx, decoder->window_object, lm_location_str, OBJECT_TO_JSVAL(obj), NULL, NULL, JSPROP_ENUMERATE | JSPROP_READONLY)) { return NULL; } if (!JS_DefineProperty(cx, decoder->document, lm_location_str, OBJECT_TO_JSVAL(obj), NULL, NULL, JSPROP_ENUMERATE | JSPROP_READONLY)) { return NULL; } /* Define the Location object (the current URL). */ url->url_decoder = HOLD_BACK_COUNT(decoder); url->url_type = FORM_TYPE_NONE; url->url_object = obj; url->index = URL_NOT_INDEXED; decoder->location = obj; return obj; }
lm_Event(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval *rval) { JSEvent *pEvent; if (!JS_InstanceOf(cx, obj, &lm_event_class, argv)) return JS_FALSE; pEvent = JS_malloc(cx, sizeof(JSEvent)); if (!pEvent) return JS_FALSE; XP_BZERO(pEvent, sizeof(JSEvent)); /* Need to decide what arguments can be used */ if (!InitEventObject(cx, obj, pEvent)) return JS_FALSE; *rval = OBJECT_TO_JSVAL(obj); return JS_TRUE; }
//----------------------------------------------------------------------------- // NetStream //----------------------------------------------------------------------------- CStreamOutNet::CStreamOutNet( MWContext* pContext ) { URL_Struct * URL_s; Chrome chrome; XP_BZERO( &chrome, sizeof( Chrome ) ); chrome.allow_close = TRUE; chrome.allow_resize = TRUE; chrome.show_scrollbar = TRUE; #ifndef XP_WIN // NOTE: need to verify this change on XP_WIN and remove the // ifndef... [ works on XP_UNIX & XP_MAC ] // chrome.type = MWContextDialog; #endif // // LTNOTE: Ownership of the 'chrome' struct isn't documented in the interface. // The windows implementation doesn't appear to keep pointers to the struct. // MWContext *pNewContext = FE_MakeNewWindow(pContext, NULL, "view-source", &chrome ); pNewContext->edit_view_source_hack = TRUE; URL_s = NET_CreateURLStruct(XP_GetString(EDT_VIEW_SOURCE_WINDOW_TITLE), NET_DONT_RELOAD); URL_s->content_type = XP_STRDUP(TEXT_PLAIN); m_pStream = NET_StreamBuilder(FO_PRESENT, URL_s, pNewContext); if(!m_pStream){ XP_ASSERT( FALSE ); m_status = EOS_FileError; } m_status = EOS_NoError; }
JSURL * lm_NewURL(JSContext *cx, MochaDecoder *decoder, LO_AnchorData *anchor_data, JSObject *document) { JSObject *obj; JSURL *url; JSString *str; if (!decoder->url_prototype) { obj = JS_InitClass(cx, decoder->window_object, decoder->event_receiver_prototype, &lm_url_class, Url, 0, url_props, NULL, NULL, NULL); if (!obj) return NULL; decoder->url_prototype = obj; } url = JS_malloc(cx, sizeof *url); if (!url) return NULL; XP_BZERO(url, sizeof *url); obj = JS_NewObject(cx, &lm_url_class, decoder->url_prototype, lm_GetOuterObject(decoder)); if (!obj || !JS_SetPrivate(cx, obj, url)) { JS_free(cx, url); return NULL; } if (!JS_DefineFunctions(cx, obj, url_methods)) return NULL; url->url_decoder = HOLD_BACK_COUNT(decoder); url->url_type = FORM_TYPE_NONE; url->index = URL_NOT_INDEXED; url->url_object = obj; str = JS_NewStringCopyZ(cx, (char *) anchor_data->anchor); if (!str) return NULL; url->href = str; if (!JS_AddNamedRoot(cx, &url->href, "url.href")) return NULL; if (anchor_data->target) { str = JS_NewStringCopyZ(cx, (char *) anchor_data->target); if (!str) return NULL; url->target = str; } if (!JS_AddNamedRoot(cx, &url->target, "url.target")) return NULL; if (anchor_data->element && anchor_data->element->type == LO_TEXT) { str = lm_LocalEncodingToStr(decoder->window_context, (char *) anchor_data->element->lo_text.text); if (!str) return NULL; url->text = str; } if (!JS_AddNamedRoot(cx, &url->text, "url.text")) return NULL; return url; }
JSObject * LM_ReflectNamedAnchor(MWContext *context, lo_NameList *name_rec, PA_Tag * tag, int32 layer_id, uint index) { JSObject *obj, *array_obj, *document; MochaDecoder *decoder; JSContext *cx; JSObjectArray *array; JSAnchor *named_anchor; lo_TopState *top_state; PRHashTable *map; JSString *str; obj = name_rec->mocha_object; if (obj) return obj; decoder = LM_GetMochaDecoder(context); if (!decoder) return NULL; cx = decoder->js_context; top_state = lo_GetMochaTopState(context); if (top_state->resize_reload) { map = lm_GetIdToObjectMap(decoder); if (map) obj = (JSObject *)PR_HashTableLookup(map, LM_GET_MAPPING_KEY(LM_NAMEDANCHORS, layer_id, index)); if (obj) { name_rec->mocha_object = obj; LM_PutMochaDecoder(decoder); return obj; } } /* Get the document object that will hold this anchor */ document = lm_GetDocumentFromLayerId(decoder, layer_id); if (!document) { LM_PutMochaDecoder(decoder); return NULL; } array_obj = lm_GetNameArray(decoder, document); if (!array_obj) { LM_PutMochaDecoder(decoder); return NULL; } array = JS_GetPrivate(cx, array_obj); if (!array) { LM_PutMochaDecoder(decoder); return NULL; } named_anchor = JS_malloc(cx, sizeof *named_anchor); if (!named_anchor) { LM_PutMochaDecoder(decoder); return NULL; } XP_BZERO(named_anchor, sizeof *named_anchor); obj = JS_NewObject(cx, &lm_anchor_class, decoder->anchor_prototype, document); if (!obj || !JS_SetPrivate(cx, obj, named_anchor)) { JS_free(cx, named_anchor); LM_PutMochaDecoder(decoder); return NULL; } /* Put obj into the document.anchors array. */ JS_DefineProperty(cx, array_obj, (char *) name_rec->name, OBJECT_TO_JSVAL(obj), NULL, NULL, JSPROP_ENUMERATE|JSPROP_READONLY); JS_AliasElement(cx, array_obj, (char *) name_rec->name, index); /* Put it in the index to object hash table */ map = lm_GetIdToObjectMap(decoder); if (map) { PR_HashTableAdd(map, LM_GET_MAPPING_KEY(LM_NAMEDANCHORS, layer_id, index), obj); } if ((jsint) index >= array->length) array->length = index + 1; named_anchor->decoder = HOLD_BACK_COUNT(decoder); named_anchor->layer_id = layer_id; named_anchor->index = index; if (name_rec->element && name_rec->element->type == LO_TEXT) { str = lm_LocalEncodingToStr(context, (char *) name_rec->element->lo_text.text); if (!str || !JS_LockGCThing(cx, str)) { LM_PutMochaDecoder(decoder); return NULL; } named_anchor->text = str; } str = JS_NewStringCopyZ(cx, (char *) name_rec->name); if (!str || !JS_LockGCThing(cx, str)) { LM_PutMochaDecoder(decoder); return NULL; } named_anchor->name = str; name_rec->mocha_object = obj; /* see if there are any attributes for event handlers */ if(tag) { PA_Block onlocate, id; /* don't hold the layout lock across compiles */ LO_UnlockLayout(); onlocate = lo_FetchParamValue(context, tag, PARAM_ONLOCATE); id = lo_FetchParamValue(context, tag, PARAM_ID); if (onlocate) { (void) lm_CompileEventHandler(decoder, id, tag->data, tag->newline_count, obj, PARAM_ONLOCATE, onlocate); PA_FREE(onlocate); } if (id) PA_FREE(id); LO_LockLayout(); } LM_PutMochaDecoder(decoder); return obj; }
void il_quantize_fs_dither(il_container *ic, const uint8 *mask, const uint8 *input_buf, int x_offset, uint8 XP_HUGE *output_buf, int width) { my_cquantize_ptr cquantize; register LOCFSERROR r_cur, g_cur, b_cur; /* current error or pixel value */ LOCFSERROR r_belowerr, g_belowerr, b_belowerr; /* error for pixel below cur */ LOCFSERROR r_bpreverr, g_bpreverr, b_bpreverr; /* error for below/prev col */ LOCFSERROR r_bnexterr, g_bnexterr, b_bnexterr; /* error for below/next col */ LOCFSERROR delta; FSERRPTR r_errorptr, g_errorptr, b_errorptr; /* fserrors[] at column before current */ const JSAMPLE* input_ptr; JSAMPLE XP_HUGE * output_ptr; IL_ColorMap *cmap = &ic->image->header.color_space->cmap; IL_RGB *map = cmap->map; /* The colormap array. */ IL_RGB *map_entry; /* Current entry in the colormap. */ uint8 *lookup_table = cmap->table; /* Lookup table for the colormap. */ const uint8 *maskp; uint8 map_index; int dir; /* 1 for left-to-right, -1 for right-to-left */ JDIMENSION col; JSAMPLE *range_limit = the_sample_range_limit; SHIFT_TEMPS cquantize = (my_cquantize_ptr) ic->quantize; output_buf += x_offset; /* Initialize output values to 0 so can process components separately */ if (mask) { output_ptr = output_buf; maskp = mask; for (col = width; col > 0; col--) *output_ptr++ &= ~*maskp++; } else { XP_BZERO((void XP_HUGE *) output_buf, (size_t) (width * SIZEOF(JSAMPLE))); } input_ptr = input_buf; output_ptr = output_buf; maskp = mask; if (cquantize->on_odd_row) { int total_offset; /* work right to left in this row */ input_ptr += 3 * width - 1; /* so point to the blue sample of the rightmost pixel */ output_ptr += width-1; dir = -1; /* => entry after last column */ total_offset = x_offset + (width + 1); r_errorptr = cquantize->fserrors[0] + total_offset; g_errorptr = cquantize->fserrors[1] + total_offset; b_errorptr = cquantize->fserrors[2] + total_offset; maskp += (width - 1); } else { /* work left to right in this row */ dir = 1; /* => entry before first column */ r_errorptr = cquantize->fserrors[0] + x_offset; g_errorptr = cquantize->fserrors[1] + x_offset; b_errorptr = cquantize->fserrors[2] + x_offset; } /* Preset error values: no error propagated to first pixel from left */ r_cur = g_cur = b_cur = 0; /* and no error propagated to row below yet */ r_belowerr = g_belowerr = b_belowerr = 0; r_bpreverr = g_bpreverr = b_bpreverr = 0; for (col = width; col > 0; col--) { /* cur holds the error propagated from the previous pixel on the * current line. Add the error propagated from the previous line * to form the complete error correction term for this pixel, and * round the error term (which is expressed * 16) to an integer. * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct * for either sign of the error value. * Note: errorptr points to *previous* column's array entry. */ r_cur = RIGHT_SHIFT(r_cur + r_errorptr[dir] + 8, 4); g_cur = RIGHT_SHIFT(g_cur + g_errorptr[dir] + 8, 4); b_cur = RIGHT_SHIFT(b_cur + b_errorptr[dir] + 8, 4); /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE. * The maximum error is +- MAXJSAMPLE; this sets the required size * of the range_limit array. */ if (dir > 0) { r_cur += GETJSAMPLE(*input_ptr); r_cur = GETJSAMPLE(range_limit[r_cur]); input_ptr++; g_cur += GETJSAMPLE(*input_ptr); g_cur = GETJSAMPLE(range_limit[g_cur]); input_ptr++; b_cur += GETJSAMPLE(*input_ptr); b_cur = GETJSAMPLE(range_limit[b_cur]); input_ptr++; } else { b_cur += GETJSAMPLE(*input_ptr); b_cur = GETJSAMPLE(range_limit[b_cur]); input_ptr--; g_cur += GETJSAMPLE(*input_ptr); g_cur = GETJSAMPLE(range_limit[g_cur]); input_ptr--; r_cur += GETJSAMPLE(*input_ptr); r_cur = GETJSAMPLE(range_limit[r_cur]); input_ptr--; } /* Select output value, accumulate into output code for this pixel */ map_index = COLORMAP_INDEX(lookup_table, r_cur, g_cur, b_cur); if (mask) { if (*maskp) *output_ptr = map_index; maskp += dir; } else { *output_ptr = map_index; } /* Compute the actual representation error at this pixel */ map_entry = map + map_index; r_cur -= GETJSAMPLE(map_entry->red); g_cur -= GETJSAMPLE(map_entry->green); b_cur -= GETJSAMPLE(map_entry->blue); /* Compute error fractions to be propagated to adjacent pixels. * Add these into the running sums, and simultaneously shift the * next-line error sums left by 1 column. */ r_bnexterr = r_cur; delta = r_cur * 2; r_cur += delta; /* form error * 3 */ r_errorptr[0] = (FSERROR) (r_bpreverr + r_cur); r_cur += delta; /* form error * 5 */ r_bpreverr = r_belowerr + r_cur; r_belowerr = r_bnexterr; r_cur += delta; /* form error * 7 */ g_bnexterr = g_cur; delta = g_cur * 2; g_cur += delta; /* form error * 3 */ g_errorptr[0] = (FSERROR) (g_bpreverr + g_cur); g_cur += delta; /* form error * 5 */ g_bpreverr = g_belowerr + g_cur; g_belowerr = g_bnexterr; g_cur += delta; /* form error * 7 */ b_bnexterr = b_cur; delta = b_cur * 2; b_cur += delta; /* form error * 3 */ b_errorptr[0] = (FSERROR) (b_bpreverr + b_cur); b_cur += delta; /* form error * 5 */ b_bpreverr = b_belowerr + b_cur; b_belowerr = b_bnexterr; b_cur += delta; /* form error * 7 */ /* At this point cur contains the 7/16 error value to be propagated * to the next pixel on the current line, and all the errors for the * next line have been shifted over. We are therefore ready to move on. * Note: the input_ptr has already been advanced. */ output_ptr += dir; /* advance output ptr to next column */ r_errorptr += dir; /* advance errorptr to current column */ g_errorptr += dir; /* advance errorptr to current column */ b_errorptr += dir; /* advance errorptr to current column */ } /* Post-loop cleanup: we must unload the final error value into the * final fserrors[] entry. Note we need not unload belowerr because * it is for the dummy column before or after the actual array. */ r_errorptr[0] = (FSERROR) r_bpreverr; /* unload prev err into array */ g_errorptr[0] = (FSERROR) g_bpreverr; /* unload prev err into array */ b_errorptr[0] = (FSERROR) b_bpreverr; /* unload prev err into array */ cquantize->on_odd_row = (cquantize->on_odd_row ? FALSE : TRUE); }