AboutDialog::AboutDialog(BaseObjectType* baseObject, const RefPtr<Gnome::Glade::Xml>& refGlade) : Gtk::Dialog(baseObject) { appInstance->logEvent("AboutDialog::AboutDialog()", SEVERITY_DEBUG); // get widgets appInstance->xml->get_widget("title", title); appInstance->xml->get_widget("linkButton", linkBtn); appInstance->xml->get_widget("link", link); appInstance->xml->get_widget("description", description); appInstance->xml->get_widget("caption1", caption1); appInstance->xml->get_widget("caption2", caption2); appInstance->xml->get_widget("caption3", caption3); appInstance->xml->get_widget("linkButton", linkBtn); appInstance->xml->get_widget("closeButton", closeBtn); appInstance->xml->get_widget("logoImage", logoImage); appInstance->xml->get_widget("thanksTV", thanksTV); // setting properties title->set_use_markup(true); title->set_label("<span font=\"16\" weight=\"bold\">" + get_application_name() + " " + appInstance->getVersion() + "</span>"); title->set_alignment(Gtk::ALIGN_CENTER); title->set_line_wrap(true); logoImage->set(appInstance->getVariable("SWIFTIM_DATA_DIR") + G_DIR_SEPARATOR + "img" + G_DIR_SEPARATOR + "logo.png"); linkBtn->set_relief(Gtk::RELIEF_NONE); linkBtn->set_focus_on_click(false); link->set_use_markup(true); link->set_label("<span color=\"#0000FF\" weight=\"bold\">" + appInstance->getVariable("SWIFTIM_HOMEPAGE") + "</span>"); link->set_line_wrap(true); description->set_use_markup(true); description->set_alignment(Gtk::ALIGN_CENTER); description->set_line_wrap(true); description->set_label( "<span weight=\"bold\">" + ustring(_("Cross-platform IM client for Mail.ru")) + "</span>\n\n" "Copyright (c) 2009 Галымжан Кожаев\n" "<kozhayev(at)gmail(dot)com>" ); RefPtr<Gtk::TextBuffer::Tag> refTag; RefPtr<Gtk::TextBuffer> buffer = thanksTV->get_buffer(); refTag = buffer->create_tag("bold"); refTag->set_property("weight", Pango::WEIGHT_BOLD); buffer->insert_with_tag(buffer->end(), ustring(_("People:")) + "\r\n", "bold"); buffer->insert(buffer->end(), "Stepan Zubashev <faiwer(at)gmail(dot)com>: " + ustring(_("Logo design")) + "\r\n\r\n"); buffer->insert_with_tag(buffer->end(), ustring(_("Projects:")) + "\r\n", "bold"); buffer->insert(buffer->end(), "GTK+ toolkit (http://www.gtk.org)" "\r\n" "GTKMM project (http://www.gtkmm.org)" "\r\n" "CodeBlocks IDE (http://www.codeblocks.org)" ); caption1->set_label(_("Information")); caption2->set_label(_("License")); caption3->set_label(_("Thanks")); // connecting signals closeBtn->signal_clicked().connect(sigc::mem_fun(*this, &AboutDialog::onCloseClicked)); linkBtn->signal_clicked().connect(sigc::mem_fun(*this, &AboutDialog::onLinkClicked)); };
void set_lyrics(DB_playItem_t *track, ustring lyrics) { signal_idle().connect_once([track, lyrics = move(lyrics)]() -> void { const char *artist, *title; { pl_lock_guard guard; if (!is_playing(track)) return; artist = deadbeef->pl_find_meta(track, "artist"); title = deadbeef->pl_find_meta(track, "title"); } if (!artist) artist = _("Unknown Artist"); if (!title) title = _("Unknown Title"); refBuffer->erase(refBuffer->begin(), refBuffer->end()); refBuffer->insert_with_tags(refBuffer->begin(), title, tagsTitle); refBuffer->insert_with_tags(refBuffer->end(), ustring("\n") + artist + "\n\n", tagsArtist); bool italic = false; bool bold = false; size_t prev_mark = 0; vector<RefPtr<TextTag>> tags; while (prev_mark != ustring::npos) { size_t italic_mark = lyrics.find("''", prev_mark); if (italic_mark == ustring::npos) break; size_t bold_mark = ustring::npos; if (italic_mark < lyrics.size() - 2 && lyrics[italic_mark + 2] == '\'') bold_mark = italic_mark; tags.clear(); if (italic) tags.push_back(tagItalic); if (bold) tags.push_back(tagBold); refBuffer->insert_with_tags(refBuffer->end(), lyrics.substr(prev_mark, min(bold_mark, italic_mark) - prev_mark), tags); if (bold_mark == ustring::npos) { prev_mark = italic_mark + 2; italic = !italic; } else { prev_mark = bold_mark + 3; bold = !bold; } } refBuffer->insert(refBuffer->end(), lyrics.substr(prev_mark)); // in case if no formatting found last = track; }); }
bool RuntimeObject::getOwnPropertyDescriptor(JSObject* object, ExecState *exec, PropertyName propertyName, PropertyDescriptor& descriptor) { RuntimeObject* thisObject = jsCast<RuntimeObject*>(object); if (!thisObject->m_instance) { throwInvalidAccessError(exec); return false; } RefPtr<Instance> instance = thisObject->m_instance; instance->begin(); Class *aClass = instance->getClass(); if (aClass) { // See if the instance has a field with the specified name. Field *aField = aClass->fieldNamed(propertyName, instance.get()); if (aField) { PropertySlot slot; slot.setCustom(thisObject, fieldGetter); instance->end(); descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete); return true; } else { // Now check if a method with specified name exists, if so return a function object for // that method. MethodList methodList = aClass->methodsNamed(propertyName, instance.get()); if (methodList.size() > 0) { PropertySlot slot; slot.setCustom(thisObject, methodGetter); instance->end(); descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete | ReadOnly); return true; } } // Try a fallback object. if (!aClass->fallbackObject(exec, instance.get(), propertyName).isUndefined()) { PropertySlot slot; slot.setCustom(thisObject, fallbackObjectGetter); instance->end(); descriptor.setDescriptor(slot.getValue(exec, propertyName), DontDelete | ReadOnly | DontEnum); return true; } } instance->end(); return instance->getOwnPropertyDescriptor(thisObject, exec, propertyName, descriptor); }
static JSValue JSC_HOST_CALL callRuntimeMethod(ExecState* exec, JSObject* function, JSValue thisValue, const ArgList& args) { RuntimeMethod* method = static_cast<RuntimeMethod*>(function); if (method->methods()->isEmpty()) return jsUndefined(); RuntimeObjectImp* imp; if (thisValue.isObject(&RuntimeObjectImp::s_info)) { imp = static_cast<RuntimeObjectImp*>(asObject(thisValue)); } else { // If thisObj is the DOM object for a plugin, get the corresponding // runtime object from the DOM object. JSValue value = thisValue.get(exec, Identifier(exec, "__apple_runtime_object")); if (value.isObject(&RuntimeObjectImp::s_info)) imp = static_cast<RuntimeObjectImp*>(asObject(value)); else return throwError(exec, TypeError); } RefPtr<Instance> instance = imp->getInternalInstance(); if (!instance) return RuntimeObjectImp::throwInvalidAccessError(exec); instance->begin(); JSValue result = instance->invokeMethod(exec, *method->methods(), args); instance->end(); return result; }
void SVGRenderSupport::applyStrokeStyleToContext(GraphicsContext* context, const RenderStyle* style, const RenderObject* object) { ASSERT(context); ASSERT(style); ASSERT(object); ASSERT(object->node()); ASSERT(object->node()->isSVGElement()); const SVGRenderStyle* svgStyle = style->svgStyle(); ASSERT(svgStyle); SVGLengthContext lengthContext(toSVGElement(object->node())); context->setStrokeThickness(svgStyle->strokeWidth()->value(lengthContext)); context->setLineCap(svgStyle->capStyle()); context->setLineJoin(svgStyle->joinStyle()); context->setMiterLimit(svgStyle->strokeMiterLimit()); RefPtr<SVGLengthList> dashes = svgStyle->strokeDashArray(); if (dashes->isEmpty()) return; DashArray dashArray; SVGLengthList::ConstIterator it = dashes->begin(); SVGLengthList::ConstIterator itEnd = dashes->end(); for (; it != itEnd; ++it) dashArray.append(it->value(lengthContext)); context->setLineDash(dashArray, svgStyle->strokeDashOffset()->value(lengthContext)); }
bool RenderThemeGtk::paintMediaSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r) { HTMLMediaElement* mediaElement = toParentMediaElement(o); if (!mediaElement) return false; GraphicsContext* context = paintInfo.context; context->save(); context->setStrokeStyle(NoStroke); float mediaDuration = mediaElement->duration(); float totalTrackWidth = r.width(); RenderStyle* style = o->style(); RefPtr<TimeRanges> timeRanges = mediaElement->buffered(); for (unsigned index = 0; index < timeRanges->length(); ++index) { float start = timeRanges->start(index, IGNORE_EXCEPTION); float end = timeRanges->end(index, IGNORE_EXCEPTION); float startRatio = start / mediaDuration; float lengthRatio = (end - start) / mediaDuration; if (!lengthRatio) continue; IntRect rangeRect(r); rangeRect.setWidth(lengthRatio * totalTrackWidth); if (index) rangeRect.move(startRatio * totalTrackWidth, 0); context->fillRoundedRect(RoundedRect(rangeRect, borderRadiiFromStyle(style)), style->visitedDependentColor(CSSPropertyColor), style->colorSpace()); } context->restore(); return false; }
bool RenderThemeQt::paintMediaSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r) { HTMLMediaElement* mediaElement = toParentMediaElement(o); if (!mediaElement) return false; QSharedPointer<StylePainter> p = getStylePainter(paintInfo); if (p.isNull() || !p->isValid()) return true; p->painter->setRenderHint(QPainter::Antialiasing, true); paintMediaBackground(p->painter, r); if (MediaPlayer* player = mediaElement->player()) { // Get the buffered parts of the media RefPtr<TimeRanges> buffered = player->buffered(); if (buffered->length() > 0 && player->duration() < std::numeric_limits<float>::infinity()) { // Set the transform and brush WorldMatrixTransformer transformer(p->painter, o, r); p->painter->setBrush(getMediaControlForegroundColor()); // Paint each buffered section for (int i = 0; i < buffered->length(); i++) { float startX = (buffered->start(i, IGNORE_EXCEPTION) / player->duration()) * 100; float width = ((buffered->end(i, IGNORE_EXCEPTION) / player->duration()) * 100) - startX; p->painter->drawRect(startX, 37, width, 26); } } } return false; }
void InspectorResourceAgent::willSendResourceRequest(unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& redirectResponse) { String requestId = IdentifiersFactory::requestId(identifier); m_resourcesData->resourceCreated(requestId, m_pageAgent->loaderId(loader)); RefPtr<InspectorObject> headers = m_state->getObject(ResourceAgentState::extraRequestHeaders); if (headers) { InspectorObject::const_iterator end = headers->end(); for (InspectorObject::const_iterator it = headers->begin(); it != end; ++it) { String value; if (it->value->asString(&value)) request.setHTTPHeaderField(it->key, value); } } request.setReportLoadTiming(true); request.setReportRawHeaders(true); if (m_state->getBoolean(ResourceAgentState::cacheDisabled)) { request.setHTTPHeaderField("Pragma", "no-cache"); request.setCachePolicy(ReloadIgnoringCacheData); request.setHTTPHeaderField("Cache-Control", "no-cache"); } RefPtr<TypeBuilder::Network::Initiator> initiatorObject = buildInitiatorObject(loader->frame() ? loader->frame()->document() : 0); m_frontend->requestWillBeSent(requestId, m_pageAgent->frameId(loader->frame()), m_pageAgent->loaderId(loader), loader->url().string(), buildObjectForResourceRequest(request), currentTime(), initiatorObject, buildObjectForResourceResponse(redirectResponse, loader)); }
void InspectorDebuggerAgent::setBreakpointByUrl(ErrorString* errorString, int lineNumber, const String* const optionalURL, const String* const optionalURLRegex, const int* const optionalColumnNumber, const String* const optionalCondition, String* outBreakpointId, RefPtr<InspectorArray>& locations) { if (!optionalURL == !optionalURLRegex) { *errorString = "Either url or urlRegex must be specified."; return; } String url = optionalURL ? *optionalURL : *optionalURLRegex; int columnNumber = optionalColumnNumber ? *optionalColumnNumber : 0; String condition = optionalCondition ? *optionalCondition : ""; bool isRegex = optionalURLRegex; String breakpointId = (isRegex ? "/" + url + "/" : url) + ':' + String::number(lineNumber) + ':' + String::number(columnNumber); RefPtr<InspectorObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints); if (breakpointsCookie->find(breakpointId) != breakpointsCookie->end()) { *errorString = "Breakpoint at specified location already exists."; return; } breakpointsCookie->setObject(breakpointId, buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition, isRegex)); m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie); ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition); for (ScriptsMap::iterator it = m_scripts.begin(); it != m_scripts.end(); ++it) { if (!matches(it->second.url, url, isRegex)) continue; RefPtr<InspectorObject> location = resolveBreakpoint(breakpointId, it->first, breakpoint); if (location) locations->pushObject(location); } *outBreakpointId = breakpointId; }
void InspectorDebuggerAgent::didParseSource(const String& scriptId, const Script& script) { // Don't send script content to the front end until it's really needed. const bool* isContentScript = script.isContentScript ? &script.isContentScript : 0; String sourceMapURL = sourceMapURLForScript(script); m_frontend->scriptParsed(scriptId, script.url, script.startLine, script.startColumn, script.endLine, script.endColumn, isContentScript, sourceMapURL); m_scripts.set(scriptId, script); if (script.url.isEmpty()) return; RefPtr<InspectorObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints); for (InspectorObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) { RefPtr<InspectorObject> breakpointObject = it->second->asObject(); bool isRegex; breakpointObject->getBoolean("isRegex", &isRegex); String url; breakpointObject->getString("url", &url); if (!matches(script.url, url, isRegex)) continue; ScriptBreakpoint breakpoint; breakpointObject->getNumber("lineNumber", &breakpoint.lineNumber); breakpointObject->getNumber("columnNumber", &breakpoint.columnNumber); breakpointObject->getString("condition", &breakpoint.condition); RefPtr<InspectorObject> location = resolveBreakpoint(it->first, scriptId, breakpoint); if (location) m_frontend->breakpointResolved(it->first, location); } }
static EncodedJSValue JSC_HOST_CALL callRuntimeMethod(ExecState* exec) { VM& vm = exec->vm(); auto scope = DECLARE_THROW_SCOPE(vm); RuntimeMethod* method = static_cast<RuntimeMethod*>(exec->jsCallee()); if (!method->method()) return JSValue::encode(jsUndefined()); RefPtr<Instance> instance; JSValue thisValue = exec->thisValue(); if (thisValue.inherits(RuntimeObject::info())) { RuntimeObject* runtimeObject = static_cast<RuntimeObject*>(asObject(thisValue)); instance = runtimeObject->getInternalInstance(); if (!instance) return JSValue::encode(RuntimeObject::throwInvalidAccessError(exec, scope)); } else { // Calling a runtime object of a plugin element? if (thisValue.inherits(JSHTMLElement::info())) instance = pluginInstance(jsCast<JSHTMLElement*>(asObject(thisValue))->wrapped()); if (!instance) return throwVMTypeError(exec, scope); } ASSERT(instance); instance->begin(); JSValue result = instance->invokeMethod(exec, method); instance->end(); return JSValue::encode(result); }
void InspectorDebuggerAgent::didParseSource(const String& sourceId, const Script& script) { // Don't send script content to the front end until it's really needed. m_frontend->scriptParsed(sourceId, script.url, script.startLine, script.startColumn, script.endLine, script.endColumn, script.isContentScript); m_scripts.set(sourceId, script); if (script.url.isEmpty()) return; RefPtr<InspectorObject> breakpointsCookie = m_inspectorState->getObject(DebuggerAgentState::javaScriptBreakpoints); for (InspectorObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) { RefPtr<InspectorObject> breakpointObject = it->second->asObject(); String breakpointURL; breakpointObject->getString("url", &breakpointURL); if (breakpointURL != script.url) continue; ScriptBreakpoint breakpoint; breakpointObject->getNumber("lineNumber", &breakpoint.lineNumber); breakpointObject->getNumber("columnNumber", &breakpoint.columnNumber); breakpointObject->getString("condition", &breakpoint.condition); RefPtr<InspectorObject> location = resolveBreakpoint(it->first, sourceId, breakpoint); if (location) m_frontend->breakpointResolved(it->first, location); } }
static EncodedJSValue JSC_HOST_CALL callRuntimeMethod(ExecState* exec) { RuntimeMethod* method = static_cast<RuntimeMethod*>(exec->callee()); if (method->methods()->isEmpty()) return JSValue::encode(jsUndefined()); RefPtr<Instance> instance; JSValue thisValue = exec->hostThisValue(); if (thisValue.inherits(&RuntimeObject::s_info)) { RuntimeObject* runtimeObject = static_cast<RuntimeObject*>(asObject(thisValue)); instance = runtimeObject->getInternalInstance(); if (!instance) return JSValue::encode(RuntimeObject::throwInvalidAccessError(exec)); } else { // Calling a runtime object of a plugin element? if (thisValue.inherits(&JSHTMLElement::s_info)) { HTMLElement* element = jsCast<JSHTMLElement*>(asObject(thisValue))->impl(); instance = pluginInstance(element); } if (!instance) return throwVMTypeError(exec); } ASSERT(instance); instance->begin(); JSValue result = instance->invokeMethod(exec, method); instance->end(); return JSValue::encode(result); }
bool RenderThemeGtk::paintMediaSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r) { GraphicsContext* context = paintInfo.context; context->fillRect(FloatRect(r), m_panelColor, ColorSpaceDeviceRGB); context->fillRect(FloatRect(IntRect(r.x(), r.y() + (r.height() - m_mediaSliderHeight) / 2, r.width(), m_mediaSliderHeight)), m_sliderColor, ColorSpaceDeviceRGB); RenderStyle* style = o->style(); HTMLMediaElement* mediaElement = toParentMediaElement(o); if (!mediaElement) return false; // Draw the buffered ranges. This code is highly inspired from // Chrome for the gradient code. float mediaDuration = mediaElement->duration(); RefPtr<TimeRanges> timeRanges = mediaElement->buffered(); IntRect trackRect = r; int totalWidth = trackRect.width(); trackRect.inflate(-style->borderLeftWidth()); context->save(); context->setStrokeStyle(NoStroke); for (unsigned index = 0; index < timeRanges->length(); ++index) { ExceptionCode ignoredException; float start = timeRanges->start(index, ignoredException); float end = timeRanges->end(index, ignoredException); int width = ((end - start) * totalWidth) / mediaDuration; IntRect rangeRect; if (!index) { rangeRect = trackRect; rangeRect.setWidth(width); } else { rangeRect.setLocation(IntPoint(trackRect.x() + start / mediaDuration* totalWidth, trackRect.y())); rangeRect.setSize(IntSize(width, trackRect.height())); } // Don't bother drawing empty range. if (rangeRect.isEmpty()) continue; IntPoint sliderTopLeft = rangeRect.location(); IntPoint sliderTopRight = sliderTopLeft; sliderTopRight.move(0, rangeRect.height()); RefPtr<Gradient> gradient = Gradient::create(sliderTopLeft, sliderTopRight); Color startColor = m_panelColor; gradient->addColorStop(0.0, startColor); gradient->addColorStop(1.0, Color(startColor.red() / 2, startColor.green() / 2, startColor.blue() / 2, startColor.alpha())); context->setFillGradient(gradient); context->fillRect(rangeRect); } context->restore(); return false; }
AnimatableStrokeDasharrayList::AnimatableStrokeDasharrayList(PassRefPtr<SVGLengthList> passLengths) { RefPtr<SVGLengthList> lengths = passLengths; SVGLengthList::ConstIterator it = lengths->begin(); SVGLengthList::ConstIterator itEnd = lengths->end(); for (; it != itEnd; ++it) m_values.append(AnimatableSVGLength::create(*it)); }
bool RuntimeObject::getOwnPropertySlot(JSCell* cell, ExecState *exec, const Identifier& propertyName, PropertySlot& slot) { RuntimeObject* thisObject = static_cast<RuntimeObject*>(cell); if (!thisObject->m_instance) { throwInvalidAccessError(exec); return false; } RefPtr<Instance> instance = thisObject->m_instance; instance->begin(); Class *aClass = instance->getClass(); if (aClass) { // See if the instance has a field with the specified name. Field *aField = aClass->fieldNamed(propertyName, instance.get()); if (aField) { slot.setCustom(thisObject, thisObject->fieldGetter); instance->end(); return true; } else { // Now check if a method with specified name exists, if so return a function object for // that method. MethodList methodList = aClass->methodsNamed(propertyName, instance.get()); if (methodList.size() > 0) { slot.setCustom(thisObject, thisObject->methodGetter); instance->end(); return true; } } // Try a fallback object. if (!aClass->fallbackObject(exec, instance.get(), propertyName).isUndefined()) { slot.setCustom(thisObject, thisObject->fallbackObjectGetter); instance->end(); return true; } } instance->end(); return instance->getOwnPropertySlot(thisObject, exec, propertyName, slot); }
void InspectorPageAgent::removeScriptToEvaluateOnLoad(ErrorString* error, const String& identifier) { RefPtr<JSONObject> scripts = m_state->getObject(PageAgentState::pageAgentScriptsToEvaluateOnLoad); if (!scripts || scripts->find(identifier) == scripts->end()) { *error = "Script not found"; return; } scripts->remove(identifier); }
void EditingStyle::removeStyleConflictingWithStyleOfNode(Node* node) { if (!node || !node->parentNode() || !m_mutableStyle) return; RefPtr<CSSMutableStyleDeclaration> parentStyle = editingStyleFromComputedStyle(computedStyle(node->parentNode())); RefPtr<CSSMutableStyleDeclaration> nodeStyle = editingStyleFromComputedStyle(computedStyle(node)); parentStyle->diff(nodeStyle.get()); CSSMutableStyleDeclaration::const_iterator end = nodeStyle->end(); for (CSSMutableStyleDeclaration::const_iterator it = nodeStyle->begin(); it != end; ++it) m_mutableStyle->removeProperty(it->id()); }
JSValue RuntimeObject::defaultValue(ExecState* exec, PreferredPrimitiveType hint) const { if (!m_instance) return throwInvalidAccessError(exec); RefPtr<Instance> instance = m_instance; instance->begin(); JSValue result = instance->defaultValue(exec, hint); instance->end(); return result; }
void RuntimeObject::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode) { if (!m_instance) { throwInvalidAccessError(exec); return; } RefPtr<Instance> instance = m_instance; instance->begin(); instance->getPropertyNames(exec, propertyNames); instance->end(); }
void InspectorReplayAgent::didCreateFrontendAndBackend(Inspector::FrontendRouter*, Inspector::BackendDispatcher*) { m_instrumentingAgents.setInspectorReplayAgent(this); ASSERT(sessionState() == WebCore::SessionState::Inactive); // Keep track of the (default) session currently loaded by ReplayController, // and any segments within the session. RefPtr<ReplaySession> session = m_page.replayController().loadedSession(); m_sessionsMap.add(session->identifier(), session); for (auto it = session->begin(); it != session->end(); ++it) m_segmentsMap.add((*it)->identifier(), *it); }
JSValue RuntimeObject::defaultValue(const JSObject* object, ExecState* exec, PreferredPrimitiveType hint) { const RuntimeObject* thisObject = jsCast<const RuntimeObject*>(object); if (!thisObject->m_instance) return throwInvalidAccessError(exec); RefPtr<Instance> instance = thisObject->m_instance; instance->begin(); JSValue result = instance->defaultValue(exec, hint); instance->end(); return result; }
static bool paintMediaSlider(RenderObject* object, const PaintInfo& paintInfo, const IntRect& rect) { HTMLMediaElement* mediaElement = toParentMediaElement(object); if (!mediaElement) return false; RenderStyle* style = object->style(); GraphicsContext* context = paintInfo.context; paintRoundedSliderBackground(rect, style, context); // Draw the buffered range. Since the element may have multiple buffered ranges and it'd be // distracting/'busy' to show all of them, show only the buffered range containing the current play head. RefPtr<TimeRanges> bufferedTimeRanges = mediaElement->buffered(); float duration = mediaElement->duration(); float currentTime = mediaElement->currentTime(); if (std::isnan(duration) || std::isinf(duration) || !duration || std::isnan(currentTime)) return true; for (unsigned i = 0; i < bufferedTimeRanges->length(); ++i) { float start = bufferedTimeRanges->start(i, ASSERT_NO_EXCEPTION); float end = bufferedTimeRanges->end(i, ASSERT_NO_EXCEPTION); if (std::isnan(start) || std::isnan(end) || start > currentTime || end < currentTime) continue; int startPosition = int(start * rect.width() / duration); int currentPosition = int(currentTime * rect.width() / duration); int endPosition = int(end * rect.width() / duration); // Add half the thumb width proportionally adjusted to the current painting position. int thumbCenter = mediaSliderThumbWidth / 2; int addWidth = thumbCenter * (1.0 - 2.0 * currentPosition / rect.width()); currentPosition += addWidth; // Draw white-ish highlight before current time. Color startColor = Color(195, 195, 195); Color endColor = Color(217, 217, 217); if (currentPosition > startPosition) paintSliderRangeHighlight(rect, style, context, startPosition, currentPosition, startColor, endColor); // Draw grey-ish highlight after current time. startColor = Color(60, 60, 60); endColor = Color(76, 76, 76); if (endPosition > currentPosition) paintSliderRangeHighlight(rect, style, context, currentPosition, endPosition, startColor, endColor); return true; } return true; }
void RuntimeObject::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode) { RuntimeObject* thisObject = jsCast<RuntimeObject*>(object); if (!thisObject->m_instance) { throwInvalidAccessError(exec); return; } RefPtr<Instance> instance = thisObject->m_instance; instance->begin(); instance->getPropertyNames(exec, propertyNames); instance->end(); }
void InspectorDebuggerAgent::removeBreakpoint(ErrorString*, const String& breakpointId) { RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints); JSONObject::iterator it = breakpointsCookie->find(breakpointId); bool isAntibreakpoint = false; if (it != breakpointsCookie->end()) { RefPtr<JSONObject> breakpointObject = it->value->asObject(); breakpointObject->getBoolean(DebuggerAgentState::isAnti, &isAntibreakpoint); breakpointsCookie->remove(breakpointId); m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie); } if (!isAntibreakpoint) removeBreakpoint(breakpointId); }
static PassRefPtr<Inspector::Protocol::Replay::ReplaySession> buildInspectorObjectForSession(PassRefPtr<ReplaySession> prpSession) { RefPtr<ReplaySession> session = prpSession; RefPtr<Inspector::Protocol::Array<SegmentIdentifier>> segments = Inspector::Protocol::Array<SegmentIdentifier>::create(); for (auto it = session->begin(); it != session->end(); ++it) segments->addItem((*it)->identifier()); RefPtr<Inspector::Protocol::Replay::ReplaySession> sessionObject = Inspector::Protocol::Replay::ReplaySession::create() .setId(session->identifier()) .setTimestamp(session->timestamp()) .setSegments(segments.release()); return sessionObject.release(); }
ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipExceptionPause(RefPtr<JavaScriptCallFrame>& topFrame) { if (m_skipAllPauses) return ScriptDebugListener::Continue; String topFrameScriptUrl = scriptURL(topFrame.get()); if (m_cachedSkipStackRegExp && !topFrameScriptUrl.isEmpty() && m_cachedSkipStackRegExp->match(topFrameScriptUrl) != -1) return ScriptDebugListener::Continue; // Prepare top frame parameters; int topFrameLineNumber = topFrame->line(); int topFrameColumnNumber = topFrame->column(); // Match against breakpoints. if (topFrameScriptUrl.isEmpty()) return ScriptDebugListener::NoSkip; RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints); for (JSONObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) { RefPtr<JSONObject> breakpointObject = it->value->asObject(); bool isAntibreakpoint; breakpointObject->getBoolean(DebuggerAgentState::isAnti, &isAntibreakpoint); if (!isAntibreakpoint) continue; int breakLineNumber; breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakLineNumber); int breakColumnNumber; breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakColumnNumber); if (breakLineNumber != topFrameLineNumber) continue; if (breakColumnNumber != -1 && breakColumnNumber != topFrameColumnNumber) continue; bool isRegex; breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex); String url; breakpointObject->getString(DebuggerAgentState::url, &url); if (!matches(topFrameScriptUrl, url, isRegex)) continue; return ScriptDebugListener::Continue; } return ScriptDebugListener::NoSkip; }
void InspectorReplayAgent::didCreateFrontendAndBackend(InspectorFrontendChannel* frontendChannel, InspectorBackendDispatcher* backendDispatcher) { m_frontendDispatcher = std::make_unique<InspectorReplayFrontendDispatcher>(frontendChannel); m_backendDispatcher = InspectorReplayBackendDispatcher::create(backendDispatcher, this); m_instrumentingAgents->setInspectorReplayAgent(this); ASSERT(sessionState() == WebCore::SessionState::Inactive); // Keep track of the (default) session currently loaded by ReplayController, // and any segments within the session. RefPtr<ReplaySession> session = m_page.replayController().loadedSession(); m_sessionsMap.add(session->identifier(), session); for (auto it = session->begin(); it != session->end(); ++it) m_segmentsMap.add((*it)->identifier(), *it); }
JSValue RuntimeObject::methodGetter(ExecState* exec, JSValue slotBase, PropertyName propertyName) { RuntimeObject* thisObj = static_cast<RuntimeObject*>(asObject(slotBase)); RefPtr<Instance> instance = thisObj->m_instance; if (!instance) return throwInvalidAccessError(exec); instance->begin(); JSValue method = instance->getMethod(exec, propertyName); instance->end(); return method; }
EncodedJSValue RuntimeObject::methodGetter(ExecState* exec, EncodedJSValue thisValue, PropertyName propertyName, JSObject*) { RuntimeObject* thisObj = jsCast<RuntimeObject*>(JSValue::decode(thisValue)); RefPtr<Instance> instance = thisObj->m_instance; if (!instance) return JSValue::encode(throwInvalidAccessError(exec)); instance->begin(); JSValue method = instance->getMethod(exec, propertyName); instance->end(); return JSValue::encode(method); }