Example #1
0
static
void ProcessListStyleTypeValue(const nsAString * aInputString, nsAString & aOutputString,
                               const char * aDefaultValueString,
                               const char * aPrependString, const char* aAppendString)
{
  aOutputString.Truncate();
  if (aInputString) {
    if (aInputString->EqualsLiteral("1")) {
      aOutputString.AppendLiteral("decimal");
    }
    else if (aInputString->EqualsLiteral("a")) {
      aOutputString.AppendLiteral("lower-alpha");
    }
    else if (aInputString->EqualsLiteral("A")) {
      aOutputString.AppendLiteral("upper-alpha");
    }
    else if (aInputString->EqualsLiteral("i")) {
      aOutputString.AppendLiteral("lower-roman");
    }
    else if (aInputString->EqualsLiteral("I")) {
      aOutputString.AppendLiteral("upper-roman");
    }
    else if (aInputString->EqualsLiteral("square")
             || aInputString->EqualsLiteral("circle")
             || aInputString->EqualsLiteral("disc")) {
      aOutputString.Append(*aInputString);
    }
  }
}
void RelationalExpr::toString(nsAString& str) {
  mLeftExpr->toString(str);

  switch (mOp) {
    case NOT_EQUAL:
      str.AppendLiteral("!=");
      break;
    case LESS_THAN:
      str.Append(char16_t('<'));
      break;
    case LESS_OR_EQUAL:
      str.AppendLiteral("<=");
      break;
    case GREATER_THAN:
      str.Append(char16_t('>'));
      break;
    case GREATER_OR_EQUAL:
      str.AppendLiteral(">=");
      break;
    default:
      str.Append(char16_t('='));
      break;
  }

  mRightExpr->toString(str);
}
NS_IMETHODIMP
nsXULProgressMeterAccessible::GetValue(nsAString& aValue)
{
  nsresult rv = nsFormControlAccessible::GetValue(aValue);
  NS_ENSURE_SUCCESS(rv, rv);

  if (!aValue.IsEmpty())
    return NS_OK;

  double maxValue = 0;
  rv = GetMaximumValue(&maxValue);
  NS_ENSURE_SUCCESS(rv, rv);

  if (maxValue != 1) {
    double curValue = 0;
    rv = GetCurrentValue(&curValue);
    NS_ENSURE_SUCCESS(rv, rv);

    double percentValue = (curValue / maxValue) * 100;
    nsAutoString value;
    value.AppendFloat(percentValue); // AppendFloat isn't available on nsAString
    value.AppendLiteral("%");
    aValue = value;
    return NS_OK;
  }

  mContent->GetAttr(kNameSpaceID_None, nsAccessibilityAtoms::value, aValue);
  if (aValue.IsEmpty())
    aValue.AppendLiteral("0");  // Empty value for progress meter = 0%

  aValue.AppendLiteral("%");
  return NS_OK;
}
NS_IMETHODIMP
sbSQLBuilderCriterionBetweenString::ToString(nsAString& _retval)
{
  AppendTableColumnTo(_retval);

  if (mNegate) {
    _retval.AppendLiteral(" not ");
  }

  _retval.AppendLiteral(" between ");

  nsAutoString escapedLeftValue(mLeftValue);
  SB_EscapeSQL(escapedLeftValue);

  nsAutoString escapedRightValue(mRightValue);
  SB_EscapeSQL(escapedRightValue);

  _retval.AppendLiteral("'");
  _retval.Append(mLeftValue);
  _retval.AppendLiteral("' and '");
  _retval.Append(mRightValue);
  _retval.AppendLiteral("'");

  return NS_OK;
}
Example #5
0
void
txNumberExpr::toString(nsAString& str)
{
    mLeftExpr->toString(str);

    switch (mOp) {
        case ADD:
            str.AppendLiteral(" + ");
            break;
        case SUBTRACT:
            str.AppendLiteral(" - ");
            break;
        case DIVIDE:
            str.AppendLiteral(" div ");
            break;
        case MODULUS:
            str.AppendLiteral(" mod ");
            break;
        case MULTIPLY:
            str.AppendLiteral(" * ");
            break;
    }

    mRightExpr->toString(str);

}
Example #6
0
void
txNodeTypeTest::toString(nsAString& aDest)
{
    switch (mNodeType) {
        case COMMENT_TYPE:
            aDest.AppendLiteral("comment()");
            break;
        case TEXT_TYPE:
            aDest.AppendLiteral("text()");
            break;
        case PI_TYPE:
            aDest.AppendLiteral("processing-instruction(");
            if (mNodeName) {
                nsAutoString str;
                mNodeName->ToString(str);
                aDest.Append(char16_t('\''));
                aDest.Append(str);
                aDest.Append(char16_t('\''));
            }
            aDest.Append(char16_t(')'));
            break;
        case NODE_TYPE:
            aDest.AppendLiteral("node()");
            break;
    }
}
nsresult
nsDOMFileReader::GetAsDataURL(nsIDOMBlob *aFile,
                              const char *aFileData,
                              uint32_t aDataLen,
                              nsAString& aResult)
{
  aResult.AssignLiteral("data:");

  nsresult rv;
  nsString contentType;
  rv = aFile->GetType(contentType);
  if (NS_SUCCEEDED(rv) && !contentType.IsEmpty()) {
    aResult.Append(contentType);
  } else {
    aResult.AppendLiteral("application/octet-stream");
  }
  aResult.AppendLiteral(";base64,");

  nsCString encodedData;
  rv = Base64Encode(Substring(aFileData, aDataLen), encodedData);
  NS_ENSURE_SUCCESS(rv, rv);

  if (!AppendASCIItoUTF16(encodedData, aResult, fallible_t())) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  return NS_OK;
}
Example #8
0
NS_IMETHODIMP
nsCSSDocumentRule::GetCssText(nsAString& aCssText)
{
  aCssText.AssignLiteral("@-moz-document ");
  for (URL *url = mURLs; url; url = url->next) {
    switch (url->func) {
      case eURL:
        aCssText.AppendLiteral("url(\"");
        break;
      case eURLPrefix:
        aCssText.AppendLiteral("url-prefix(\"");
        break;
      case eDomain:
        aCssText.AppendLiteral("domain(\"");
        break;
    }
    nsCAutoString escapedURL(url->url);
    escapedURL.ReplaceSubstring("\"", "\\\""); // escape quotes
    AppendUTF8toUTF16(escapedURL, aCssText);
    aCssText.AppendLiteral("\"), ");
  }
  aCssText.Cut(aCssText.Length() - 2, 1); // remove last ,

  return nsCSSGroupRule::AppendRulesToCssText(aCssText);
}
NS_IMETHODIMP
nsSVGPreserveAspectRatio::GetValueString(nsAString& aValue)
{
  // XXX: defer isn't stored

  switch (mAlign) {
    case SVG_PRESERVEASPECTRATIO_NONE:
      aValue.AssignLiteral("none");
      break;
    case SVG_PRESERVEASPECTRATIO_XMINYMIN:
      aValue.AssignLiteral("xMinYMin");
      break;
    case SVG_PRESERVEASPECTRATIO_XMIDYMIN:
      aValue.AssignLiteral("xMidYMin");
      break;
    case SVG_PRESERVEASPECTRATIO_XMAXYMIN:
      aValue.AssignLiteral("xMaxYMin");
      break;
    case SVG_PRESERVEASPECTRATIO_XMINYMID:
      aValue.AssignLiteral("xMinYMid");
      break;
    case SVG_PRESERVEASPECTRATIO_XMIDYMID:
      aValue.AssignLiteral("xMidYMid");
      break;
    case SVG_PRESERVEASPECTRATIO_XMAXYMID:
      aValue.AssignLiteral("xMaxYMid");
      break;
    case SVG_PRESERVEASPECTRATIO_XMINYMAX:
      aValue.AssignLiteral("xMinYMax");
      break;
    case SVG_PRESERVEASPECTRATIO_XMIDYMAX:
      aValue.AssignLiteral("xMidYMax");
      break;
    case SVG_PRESERVEASPECTRATIO_XMAXYMAX:
      aValue.AssignLiteral("xMaxYMax");
      break;
    default:
      NS_NOTREACHED("Unknown value for mAlign");
  }

  // XXX: meetOrSlice may not have been specified in the attribute

  if (mAlign != SVG_PRESERVEASPECTRATIO_NONE) {
    switch (mMeetOrSlice) {
      case SVG_MEETORSLICE_MEET:
        aValue.AppendLiteral(" meet");
        break;
      case SVG_MEETORSLICE_SLICE:
        aValue.AppendLiteral(" slice");
        break;
      default:
        NS_NOTREACHED("Unknown value for mMeetOrSlice");
    }
  }

  return NS_OK;
}
//-------------------------------------
//
// GetExcludedFolders
//
nsresult
sbDeviceXMLInfo::GetExcludedFolders(nsAString & aExcludedFolders)
{
  nsresult rv;

  aExcludedFolders.Truncate();

  // Do nothing more if no device info element.
  if (!mDeviceInfoElement)
    return NS_OK;

  // Get the list of exclude folder nodes.
  nsTArray< nsCOMPtr<nsIDOMNode> > excludeNodeList;
  rv = GetDeviceInfoNodes(NS_LITERAL_STRING("excludefolder"), excludeNodeList);
  NS_ENSURE_SUCCESS(rv, rv);

  // Get all excluded folders.
  PRUint32 nodeCount = excludeNodeList.Length();
  const char * delimiter = "";
  for (PRUint32 i = 0; i < nodeCount; i++) {
    // Get the next exclude folder element.
    nsCOMPtr<nsIDOMElement> excludeElement;
    excludeElement = do_QueryInterface(excludeNodeList[i], &rv);
    if (NS_SUCCEEDED(rv)) {
      nsString excludeStr;

      // The url attribute, if present, will contain a literal path.
      // Remove any leading slash to distinguish literal paths from
      // patterns
      rv = excludeElement->GetAttribute(NS_LITERAL_STRING("url"), excludeStr);
      NS_ENSURE_SUCCESS(rv, rv);
      if (excludeStr.Length() > 0 && excludeStr[0] == L'/') {
        excludeStr.Cut(0, 1);
      }
      if (!excludeStr.IsEmpty()) {
        aExcludedFolders.AppendLiteral(delimiter);
        aExcludedFolders.Append(excludeStr);
        delimiter = ",";
      }

      // The match attribute, if present, will contain a folder name pattern.
      // Add a leading and trailing slash to distinguish patterns from literal
      // paths.  The pattern itself may not contain any slashes
      rv = excludeElement->GetAttribute(NS_LITERAL_STRING("match"), excludeStr);
      NS_ENSURE_SUCCESS(rv, rv);
      if (!excludeStr.IsEmpty() && excludeStr.Find("/") == -1) {
        aExcludedFolders.AppendLiteral(delimiter);
        aExcludedFolders.AppendLiteral("/");
        aExcludedFolders.Append(excludeStr);
        aExcludedFolders.AppendLiteral("/");
        delimiter = ",";
      }
    }
  }
  return NS_OK;
}
void
sbSQLBuilderCriterionBase::AppendMatchTo(nsAString& aStr)
{
  switch(mMatchType) {
    case sbISQLWhereBuilder::MATCH_EQUALS:
      aStr.AppendLiteral(" = ");
      break;
    case sbISQLWhereBuilder::MATCH_NOTEQUALS:
      aStr.AppendLiteral(" != ");
      break;
    case sbISQLWhereBuilder::MATCH_GREATER:
      aStr.AppendLiteral(" > ");
      break;
    case sbISQLWhereBuilder::MATCH_GREATEREQUAL:
      aStr.AppendLiteral(" >= ");
      break;
    case sbISQLWhereBuilder::MATCH_LESS:
      aStr.AppendLiteral(" < ");
      break;
    case sbISQLWhereBuilder::MATCH_LESSEQUAL:
      aStr.AppendLiteral(" <= ");
      break;
    case sbISQLWhereBuilder::MATCH_LIKE:
      aStr.AppendLiteral(" like ");
      break;
    case sbISQLWhereBuilder::MATCH_NOTLIKE:
      aStr.AppendLiteral(" not like ");
      break;
    case sbISQLWhereBuilder::MATCH_MATCH:
      aStr.AppendLiteral(" match ");
      break;
    default:
      NS_NOTREACHED("Unknown Match Type");
  }
}
Example #12
0
NS_IMETHODIMP ChangeAttributeTxn::GetTxnDescription(nsAString& aString)
{
    aString.AssignLiteral("ChangeAttributeTxn: [mRemoveAttribute == ");

    if (!mRemoveAttribute)
        aString.AppendLiteral("false] ");
    else
        aString.AppendLiteral("true] ");
    aString += mAttribute;
    return NS_OK;
}
Example #13
0
void txUnionPattern::toString(nsAString& aDest) {
#  ifdef DEBUG
  aDest.AppendLiteral("txUnionPattern{");
#  endif
  for (uint32_t i = 0; i < mLocPathPatterns.Length(); ++i) {
    if (i != 0) aDest.AppendLiteral(" | ");
    mLocPathPatterns[i]->toString(aDest);
  }
#  ifdef DEBUG
  aDest.Append(char16_t('}'));
#  endif
}
NS_IMETHODIMP ChangeCSSInlineStyleTxn::GetTxnDescription(nsAString& aString)
{
  aString.AssignLiteral("ChangeCSSInlineStyleTxn: [mRemoveProperty == ");

  if (!mRemoveProperty)
    aString.AppendLiteral("false] ");
  else
    aString.AppendLiteral("true] ");
  nsAutoString tempString;
  mProperty->ToString(tempString);
  aString += tempString;
  return NS_OK;
}
Example #15
0
NS_IMETHODIMP
ChangeAttributeTxn::GetTxnDescription(nsAString& aString)
{
  aString.AssignLiteral("ChangeAttributeTxn: [mRemoveAttribute == ");

  if (mRemoveAttribute) {
    aString.AppendLiteral("true] ");
  } else {
    aString.AppendLiteral("false] ");
  }
  aString += nsDependentAtomString(mAttribute);
  return NS_OK;
}
Example #16
0
NS_IMETHODIMP
ChangeStyleTxn::GetTxnDescription(nsAString& aString)
{
  aString.AssignLiteral("ChangeStyleTxn: [mRemoveProperty == ");

  if (mRemoveProperty) {
    aString.AppendLiteral("true] ");
  } else {
    aString.AppendLiteral("false] ");
  }
  aString += nsDependentAtomString(mProperty);
  return NS_OK;
}
NS_IMETHODIMP
sbSQLBuilderCriterionNull::ToString(nsAString& _retval)
{
  AppendTableColumnTo(_retval);

  if (mMatchType == sbISQLWhereBuilder::MATCH_EQUALS) {
    _retval.AppendLiteral(" is null");
  }
  else {
    _retval.AppendLiteral(" is not null");
  }
  return NS_OK;
}
Example #18
0
NS_IMETHODIMP
nsFileView::GetCellProperties(int32_t aRow, nsITreeColumn* aCol,
                              nsAString& aProps)
{
  uint32_t dirCount = mDirList.Length();

  if (aRow < (int32_t) dirCount)
    aProps.AppendLiteral("directory");
  else if (aRow < mTotalRows)
    aProps.AppendLiteral("file");

  return NS_OK;
}
Example #19
0
NS_IMETHODIMP
CSSNameSpaceRuleImpl::GetCssText(nsAString& aCssText)
{
  aCssText.AssignLiteral("@namespace ");
  if (mPrefix) {
    nsString atomStr;
    mPrefix->ToString(atomStr);
    aCssText.Append(atomStr);
    aCssText.AppendLiteral(" ");
  }
  aCssText.AppendLiteral("url(");
  aCssText.Append(mURLSpec);
  aCssText.Append(NS_LITERAL_STRING(");"));
  return NS_OK;
}
NS_IMETHODIMP
sbSQLBuilderCriterionIn::ToString(nsAString& _retval)
{
  AppendTableColumnTo(_retval);

  _retval.AppendLiteral(" in (");

  PRUint32 len = mInItems.Length();
  for (PRUint32 i = 0; i < len; i++) {
    const sbInItem& ii = mInItems[i];

    switch(ii.type) {
      case eIsNull:
        /* not implemented */
        break;
      case eString:
      {
        nsAutoString escapedValue(ii.stringValue);
        SB_EscapeSQL(escapedValue);

        _retval.AppendLiteral("'");
        _retval.Append(escapedValue);
        _retval.AppendLiteral("'");
        break;
      }
      case eInteger32:
        _retval.AppendInt(ii.int32Value);
        break;
      case eSubquery:
      {
        nsresult rv;
        nsAutoString sql;
        rv = ii.subquery->ToString(sql);
        NS_ENSURE_SUCCESS(rv, rv);
        _retval.Append(sql);
        break;
      }
    }

    if (i + 1 < len) {
      _retval.AppendLiteral(", ");
    }
  }

  _retval.AppendLiteral(")");

  return NS_OK;
}
Example #21
0
NS_IMETHODIMP
nsSVGPathSegList::GetValueString(nsAString& aValue)
{
  aValue.Truncate();

  PRInt32 count = mSegments.Count();

  if (count<=0) return NS_OK;

  PRInt32 i = 0;
  
  while (1) {
    nsIDOMSVGPathSeg* seg = ElementAt(i);
    nsCOMPtr<nsISVGValue> val = do_QueryInterface(seg);
    NS_ASSERTION(val, "path segment doesn't implement required interface");
    if (!val) continue;
    nsAutoString str;
    val->GetValueString(str);
    aValue.Append(str);

    if (++i >= count) break;

    aValue.AppendLiteral(" ");
  }
  
  return NS_OK;
}
Example #22
0
NS_IMETHODIMP
nsNSSCertificate::GetUsagesString(bool localOnly,
                                  uint32_t   *_verified,
                                  nsAString &_usages)
{
  nsNSSShutDownPreventionLock locker;
  if (isAlreadyShutDown())
    return NS_ERROR_NOT_AVAILABLE;

  nsresult rv;
  const int max_usages = 13;
  PRUnichar *tmpUsages[max_usages];
  const char *suffix = "_p";
  uint32_t tmpCount;
  nsUsageArrayHelper uah(mCert);
  rv = uah.GetUsagesArray(suffix, localOnly, max_usages, _verified, &tmpCount, tmpUsages);
  NS_ENSURE_SUCCESS(rv,rv);
  _usages.Truncate();
  for (uint32_t i=0; i<tmpCount; i++) {
    if (i>0) _usages.AppendLiteral(",");
    _usages.Append(tmpUsages[i]);
    nsMemory::Free(tmpUsages[i]);
  }
  return NS_OK;
}
Example #23
0
void UnionExpr::toString(nsAString& dest) {
  uint32_t i;
  for (i = 0; i < mExpressions.Length(); ++i) {
    if (i > 0) dest.AppendLiteral(" | ");
    mExpressions[i]->toString(dest);
  }
}
nsresult nsTextAddress::ReadRecord(nsIUnicharLineInputStream *aLineStream,
                                   nsAString &aLine, bool *aMore) {
  bool more = true;
  uint32_t numQuotes = 0;
  nsresult rv;
  nsAutoString line;

  // ensure aLine is empty
  aLine.Truncate();

  do {
    if (!more) {
      // No more, so we must have an incorrect file.
      rv = NS_ERROR_FAILURE;
    } else {
      // Read the line and append it
      rv = aLineStream->ReadLine(line, &more);
      if (NS_SUCCEEDED(rv)) {
        if (!aLine.IsEmpty()) aLine.AppendLiteral(MSG_LINEBREAK);
        aLine.Append(line);

        numQuotes += MsgCountChar(line, char16_t('"'));
      }
    }
    // Continue whilst everything is ok, and we have an odd number of quotes.
  } while (NS_SUCCEEDED(rv) && (numQuotes % 2 != 0));

  *aMore = more;
  return rv;
}
NS_IMETHODIMP
sbDownloadButtonPropertyInfo::GetCellProperties(const nsAString& aValue,
                                                nsAString& _retval)
{
  sbDownloadButtonPropertyValue value(aValue);

  switch(value.GetMode()) {
    case sbDownloadButtonPropertyValue::eNew:
      _retval.AssignLiteral("button");
      break;
    case sbDownloadButtonPropertyValue::eStarting:
      _retval.AssignLiteral("progressNotStarted");
      break;
    case sbDownloadButtonPropertyValue::eComplete:
      _retval.AssignLiteral("progressCompleted");
      break;
    case sbDownloadButtonPropertyValue::ePaused:
      _retval.AssignLiteral("progressPaused");
      break;
    case sbDownloadButtonPropertyValue::eFailed:
      _retval.AssignLiteral("button progressFailed");
      break;
    default:
      _retval.Truncate();
  }

  _retval.AppendLiteral(" downloadbutton");

  return NS_OK;
}
NS_IMETHODIMP
nsFaviconService::GetFaviconDataAsDataURL(nsIURI* aFaviconURI,
                                          nsAString& aDataURL)
{
  NS_ENSURE_ARG(aFaviconURI);

  PRUint8* data;
  PRUint32 dataLen;
  nsCAutoString mimeType;

  nsresult rv = GetFaviconData(aFaviconURI, mimeType, &dataLen, &data);
  NS_ENSURE_SUCCESS(rv, rv);

  if (!data) {
    aDataURL.SetIsVoid(true);
    return NS_OK;
  }

  char* encoded = PL_Base64Encode(reinterpret_cast<const char*>(data),
                                  dataLen, nsnull);
  nsMemory::Free(data);

  if (!encoded)
    return NS_ERROR_OUT_OF_MEMORY;

  aDataURL.AssignLiteral("data:");
  AppendUTF8toUTF16(mimeType, aDataURL);
  aDataURL.AppendLiteral(";base64,");
  AppendUTF8toUTF16(encoded, aDataURL);

  nsMemory::Free(encoded);
  return NS_OK;
}
Example #27
0
void
FilterExpr::toString(nsAString& str)
{
    if ( expr ) expr->toString(str);
    else str.AppendLiteral("null");
    PredicateList::toString(str);
}
NS_IMETHODIMP
nsSVGTransformList::GetValueString(nsAString& aValue)
{
  aValue.Truncate();

  PRInt32 count = mTransforms.Count();

  if (count<=0) return NS_OK;

  PRInt32 i = 0;
  
  while (1) {
    nsIDOMSVGTransform* transform = ElementAt(i);

    nsCOMPtr<nsISVGValue> val = do_QueryInterface(transform);
    nsAutoString str;
    val->GetValueString(str);
    aValue.Append(str);

    if (++i >= count) break;

    aValue.AppendLiteral(" ");
  }
  
  return NS_OK;

}
NS_IMETHODIMP
nsSVGPathSegList::GetValueString(nsAString& aValue)
{
  aValue.Truncate();

  PRInt32 count = mSegments.Count();

  if (count<=0) return NS_OK;

  PRInt32 i = 0;

  while (1) {
    nsSVGPathSeg* seg = static_cast<nsSVGPathSeg*>(mSegments.ObjectAt(i));

    nsAutoString str;
    seg->GetValueString(str);
    aValue.Append(str);

    if (++i >= count) break;

    aValue.AppendLiteral(" ");
  }

  return NS_OK;
}
Example #30
0
void
nsCSSRect::AppendToString(nsCSSProperty aProperty, nsAString& aResult) const
{
  NS_ABORT_IF_FALSE(mTop.GetUnit() != eCSSUnit_Null &&
                    mTop.GetUnit() != eCSSUnit_Inherit &&
                    mTop.GetUnit() != eCSSUnit_Initial,
                    "parser should have used a bare value");

  if (eCSSProperty_border_image_slice == aProperty ||
      eCSSProperty_border_image_width == aProperty ||
      eCSSProperty_border_image_outset == aProperty) {
    NS_NAMED_LITERAL_STRING(space, " ");

    mTop.AppendToString(aProperty, aResult);
    aResult.Append(space);
    mRight.AppendToString(aProperty, aResult);
    aResult.Append(space);
    mBottom.AppendToString(aProperty, aResult);
    aResult.Append(space);
    mLeft.AppendToString(aProperty, aResult);
  } else {
    NS_NAMED_LITERAL_STRING(comma, ", ");

    aResult.AppendLiteral("rect(");
    mTop.AppendToString(aProperty, aResult);
    aResult.Append(comma);
    mRight.AppendToString(aProperty, aResult);
    aResult.Append(comma);
    mBottom.AppendToString(aProperty, aResult);
    aResult.Append(comma);
    mLeft.AppendToString(aProperty, aResult);
    aResult.Append(PRUnichar(')'));
  }
}