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);
}
