C++ qstrdup函数代码示例

void MidiWinMM::openDevices()
{
	m_inputDevices.clear();
	for( unsigned int i = 0; i < midiInGetNumDevs(); ++i )
	{
		MIDIINCAPS c;
		midiInGetDevCaps( i, &c, sizeof( c ) );
		HMIDIIN hm = 0;
		MMRESULT res = midiInOpen( &hm, i, (DWORD_PTR) &inputCallback,
						(DWORD_PTR) this,
							CALLBACK_FUNCTION );
		if( res == MMSYSERR_NOERROR )
		{
			m_inputDevices[hm] = qstrdup( c.szPname );
			midiInStart( hm );
		}
	}

	m_outputDevices.clear();
	for( unsigned int i = 0; i < midiOutGetNumDevs(); ++i )
	{
		MIDIOUTCAPS c;
		midiOutGetDevCaps( i, &c, sizeof( c ) );
		HMIDIOUT hm = 0;
		MMRESULT res = midiOutOpen( &hm, i, 0, 0, CALLBACK_NULL );
		if( res == MMSYSERR_NOERROR )
		{
			m_outputDevices[hm] = qstrdup( c.szPname );
		}
	}
}

VlcInstance::VlcInstance(const QStringList &args,
                         QObject *parent)
    : QObject(parent),
      _vlcInstance(0),
      _status(false)
{
// Convert arguments to required format
#if defined(Q_OS_WIN32) // Will be removed on Windows if confirmed working
    char **argv = (char **)malloc(sizeof(char **) * args.count());
    for (int i = 0; i < args.count(); ++i)
        argv[i] = (char *)qstrdup(args.at(i).toUtf8().data());
#else
    char *argv[args.count()];
    for (int i = 0; i < args.count(); ++i)
        argv[i] = (char *)qstrdup(args.at(i).toUtf8().data());
#endif

    // Create new libvlc instance
    _vlcInstance = libvlc_new(args.count(), argv);

    qRegisterMetaType<Vlc::Meta>("Vlc::Meta");
    qRegisterMetaType<Vlc::State>("Vlc::State");

    VlcError::showErrmsg();

    // Check if instance is running
    if(_vlcInstance) {
        _status = true;
        qDebug() << "VLC-Qt" << libVersion() << "initialised";
        qDebug() << "Using libvlc version:" << version();
    } else {
        qCritical() << "VLC-Qt Error: libvlc failed to load!";
    }
}

VlcInstance::VlcInstance(const QStringList &args, QObject *parent)
    : QObject(parent), _vlcInstance(0)
{
#if defined(Q_OS_WIN32)
    char **argv = (char **)malloc(sizeof(char **) * args.count());
    for (int i = 0; i < args.count(); ++i)
        argv[i] = (char *)qstrdup(args.at(i).toUtf8().data());
#else
    char *argv[args.count()];
    for (int i = 0; i < args.count(); ++i)
        argv[i] = (char *)qstrdup(args.at(i).toUtf8().data());
#endif

    _vlcInstance = libvlc_new(args.count(), argv);

    qRegisterMetaType<Vlc::Meta>("Vlc::Meta");
    qRegisterMetaType<Vlc::State>("Vlc::State");

    VlcError::errmsg();

    if(!_vlcInstance)
    {
        qDebug() << "vlc failed to load!";
        abort();
    }
}

static bool compare(const QList<QPair<QString, QString> > &actual, const QueryItems &expected,
                    const char *actualStr, const char *expectedStr, const char *file, int line)
{
    return QTest::compare_helper(actual == expected, "Compared values are not the same",
                                 qstrdup(prettyList(actual)), qstrdup(prettyList(expected).data()),
                                 actualStr, expectedStr, file, line);
}

QStringList KISS::getFileList(packageInfo *p)
{
  QString vb, fn;
  QString name;
  char mode;

  fn = p->getFilename();
  if(!fn.isEmpty())
    mode = 'u';
  else
    mode = 'i';

  QStringList filelist;

  switch(mode)
    {
      ////////////////////////////////////////////////////////////////////////
      // query an installed package!
    case 'i':
      name = p->getProperty("name");

      reader.setup("kiss");
      *reader.proc << "-f" << name;
      if (reader.start(0,FALSE)) {
	char *buffer = qstrdup(reader.buf.ascii());
	char *str = strtok(buffer,"\n");
	if (str) {
	  do {
	    filelist.append(str);
	  } while ((str = strtok(NULL,"\n")));
	}
	delete [] buffer;
      }
      break;

      ////////////////////////////////////////////////////////////////////
      // query an uninstalled package
    case 'u':
      reader.setup("perl");
      *reader.proc << fn << "-f";
      if (reader.start(0,TRUE)) {
	char *buffer = qstrdup(reader.buf.ascii());
	char *str = strtok(buffer,"\n");
	if (str) {
	  do {
	    filelist.append(strdup(str));
	  } while ((str = strtok(NULL,"\n")));
	}
	delete [] buffer;
      }
      break;
    }

  return filelist;
}

void VideosWindow::onVideoSelected(QModelIndex index)
{
    if (index.data(UserRoleHeader).toBool()) return;

    this->setEnabled(false);

    VideoNowPlayingWindow *window = new VideoNowPlayingWindow(this, mafwRegistry);
    window->showFullScreen();

    connect(window, SIGNAL(destroyed()), this, SLOT(onChildClosed()));
    ui->indicator->inhibit();

    playlist->assignVideoPlaylist();
    playlist->clear();

    int selectedRow;
    int indexOffset = 0;
    int videoCount = 0;
    gchar** videoAddBuffer = new gchar*[objectModel->rowCount()+1];

    bool filter = QSettings().value("main/playlistFilter", false).toBool();

    if (filter) {
        selectedRow = index.row();
        for (int i = 0; i < objectProxyModel->rowCount(); i++)
            if (!objectProxyModel->index(i,0).data(UserRoleHeader).toBool())
                videoAddBuffer[videoCount++] = qstrdup(objectProxyModel->index(i,0).data(UserRoleObjectID).toString().toUtf8());
            else if (i < selectedRow)
                ++indexOffset;
    } else {
        selectedRow = objectProxyModel->mapToSource(index).row();
        for (int i = 0; i < objectModel->rowCount(); i++)
            if (!objectModel->item(i)->data(UserRoleHeader).toBool())
                videoAddBuffer[videoCount++] = qstrdup(objectModel->item(i)->data(UserRoleObjectID).toString().toUtf8());
            else if (i < selectedRow)
                ++indexOffset;
    }

    videoAddBuffer[videoCount] = NULL;

    playlist->appendItems((const gchar**) videoAddBuffer);

    for (int i = 0; i < videoCount; i++)
        delete[] videoAddBuffer[i];
    delete[] videoAddBuffer;

    mafwRenderer->gotoIndex(selectedRow-indexOffset);
    window->play();
}

//--------------------------------------------------------------------------
char *uniremap_init(char *table)
{
  const char *cur = setlocale(LC_CTYPE, NULL);
  if(!cur) cur = "C"; // PARANOYA
  cur = qstrdup(cur);

#ifdef __UNIX__
  table = create_map("", &lm[0], table);
  lm[1] = lm[0];
#else
  {
    char  s[16];
    int oemcp, acp = get_codepages(&oemcp);
    if ( acp == CP_ACP )      acp   = GetACP();
    if ( oemcp == CP_OEMCP )  oemcp = GetOEMCP();
    qsnprintf(s, sizeof(s), ".%u", oemcp);
    table = create_map(s, &lm[0], table);
    qsnprintf(s, sizeof(s), ".%u", acp);
    create_map(s, &lm[1], NULL);
  }
#endif
  setlocale(LC_CTYPE, cur); // restore default locale
  qfree((void*)cur);
  return(table);
}

	char* toString(const MapColor& c)
	{
		auto spot_method = QTest::toString(c.getSpotColorMethod());
		auto cmyk_method = QTest::toString(c.getCmykColorMethod());
		auto rgb_method  = QTest::toString(c.getRgbColorMethod());
		
		QByteArray ba;
		ba.reserve(1000);
		ba += "MapColor(";
		ba += QByteArray::number(c.getPriority());
		ba += " ";
		ba += c.getName().toLocal8Bit();
		ba += " (SPOT: ";
		ba += spot_method;
		ba += " ";
		ba += c.getSpotColorName().toLocal8Bit();
		ba += (c.getKnockout() ? " k.o." : " ---");
		ba += " [";
		ba += QByteArray::number(c.getOpacity()*100.0,'f',0);
		ba += "] CMYK: ";
		ba += cmyk_method;
		const MapColorCmyk& cmyk = c.getCmyk();
		ba += QString::fromLatin1(" %1/%2/%3/%4").arg(cmyk.c*100.0,0,'f',1).arg(cmyk.m*100.0,0,'f',1).arg(cmyk.y*100.0,0,'f',1).arg(cmyk.k*100.0,0,'f',1).toLocal8Bit();
		ba += " RGB: ";
		ba += rgb_method;
		const MapColorRgb& rgb = c.getRgb();
		ba += QString::fromLatin1(" %1/%2/%3").arg(rgb.r*255.0,0,'f',0).arg(rgb.g*255.0,0,'f',0).arg(rgb.b*255.0,0,'f',0).toLocal8Bit();
		ba += ")";
		
		delete [] spot_method;
		delete [] cmyk_method;
		delete [] rgb_method;
		
		return qstrdup(ba.data());
	}

int Cce152::RecTape(void)
{

    // Display the Save dialog box.
    TapeFileName = QFileDialog::getSaveFileName(
                    mainwindow,
                    "Choose a filename to save under",
                    ".",
                    "Wav Files (*.wav)");
    QFile file(TapeFileName);

    char * str = qstrdup(TapeFileName.toLocal8Bit());

    //if (!file.open(QIODevice::WriteOnly))
    if ((info.ptrFd = fopen(str,"wb"))==NULL)
    {
        AddLog(LOG_TAPE,tr("ERROR: Can't create the wav file."));
        MSG_ERROR(tr("Failed to create file"));
        return 0;
    }

    // create th header
    WriteHeadToWav (10,
                    16000,//pTIMER->pPC->Tape_Base_Freq*2,
                    &info);
    info.bitLen = 0x20;
    info.freq = 16000;//pTIMER->pPC->Tape_Base_Freq*2;
//       ptrFile->bitLen = (freq * 8) / ptrFile->freq ;


    mode = RECORD;

    return (1);
}

static trace::StructSig *
createStructSig(const ApiStruct &str, unsigned id)
{
    ApiStruct::Signature aSig = str.signature();

    trace::StructSig *sig = new trace::StructSig();
    sig->id = id;
    sig->name = qstrdup(aSig.name.toLocal8Bit());
    sig->num_members = aSig.memberNames.count();
    char **member_names = new char*[aSig.memberNames.count()];
    sig->member_names = (const char **)member_names;
    for (int i = 0; i < aSig.memberNames.count(); ++i) {
        member_names[i] = qstrdup(aSig.memberNames[i].toLocal8Bit());
    }
    return sig;
}

//
// return html rendered markdown of note text
//
QString Note::toMarkdownHtml() {
    hoedown_renderer *renderer = hoedown_html_renderer_new( HOEDOWN_HTML_USE_XHTML, 16 );
    hoedown_document *document = hoedown_document_new(renderer, (hoedown_extensions) HOEDOWN_EXT_SPAN, 16);

    QString str = this->noteText;

    unsigned char *sequence = (unsigned char*)qstrdup( str.toUtf8().constData() );
    int length = strlen( (char*) sequence );

    // return an empty string if the note is empty
    if ( length == 0 )
    {
        return "";
    }

    hoedown_buffer *html = hoedown_buffer_new( length );

    // render markdown html
    hoedown_document_render( document, html, sequence, length );

    // get markdown html
    QString result = QString::fromUtf8( (char*) html->data, html->size );

    /* Cleanup */
    free(sequence);
    hoedown_buffer_free(html);

    hoedown_document_free(document);
    hoedown_html_renderer_free(renderer);

    return result;
}

void KuickShow::initImlib()
{
    ImData *idata = kdata->idata;
    ImlibInitParams par;
    initImlibParams( idata, &par );

    id = Imlib_init_with_params( x11Display(), &par );
    if ( !id ) {
        initImlibParams( idata, &par );

        qWarning("*** KuickShow: Whoops, can't initialize imlib, trying my own palettefile now.");
        QString paletteFile = locate( "data", "kuickshow/im_palette.pal" );
        // ### - does the qstrdup() cure the segfault in imlib eventually?
        char *file = qstrdup( paletteFile.local8Bit() );
        par.palettefile = file;
        par.flags |= PARAMS_PALETTEFILE;

        qWarning("Palettefile: %s", par.palettefile );

        id = Imlib_init_with_params( x11Display(), &par );

        if ( !id ) {
            QString tmp = i18n("Unable to initialize \"Imlib\".\n"
                               "Start kuickshow from the command line "
                               "and look for error messages.\n"
                               "The program will now quit.");
            KMessageBox::error( this, tmp, i18n("Fatal Imlib Error") );

            FileCache::shutdown();
            ::exit(1);
        }
    }
}

const char* OtrInternal::account_name(const char* account,
                                      const char* protocol)
{
    Q_UNUSED(protocol);
    return qstrdup(m_callback->humanAccountPublic(QString::fromUtf8(account))
                                                 .toUtf8().constData());
}

packageInfo *KISS::collectInfo(const char *_inp)
{
  QMap<QString, QString> a;

  char *str, *xstr;
  QString qstr;

  char *inp = qstrdup(_inp);
  str = strtok(inp,"\n");
  do {
    xstr = strchr(str,':');
    if (*str == ' ')
      str++;
    if (!strncmp("package",str,7))
      break;
  } while ((str = strtok(NULL,"\n")));

  // parse 'name: text' elements

  if (str) {
    do {
      if (str[0] == 0)
	break;

    xstr = strchr(str,':');
    if (xstr) {
      *xstr++ = 0;
      xstr++;

      for( int i = 0; str[ i ] != '\0'; ++i )
        str[ i ] = tolower( str[ i ] );

      if (*str == ' ')
	str++;

      if (!strcmp("package",str)) {
	a.insert("name", xstr);
      } else if (!strcmp("name",str)) {
	a.insert("summary", xstr);
      } else if (!strcmp("section",str)) {
	a.insert("group", xstr);
      } else if (!strcmp("size",str)) {
	a.insert("file-size", xstr);
      } else if (!strcmp("installed-size",str)) {
	QString str = xstr;
	a.insert("size", str + "000");
      } else {
	a.insert(str, xstr);
      }
    }
    } while ((str = strtok(NULL,"\n")));
  }

  packageInfo *i = new packageInfo(a,this);
  i->packageState = packageInfo::INSTALLED;
  i->fixup();
  delete [] inp;
  return i;

}

static void decode_version (const char *_buf, int *version,
			    int *modification, int *patch)
  {
    char *buffer = qstrdup(_buf);
    char *buf = buffer;
    *version      = (int) strtoul (buf, &buf, 10);
    *modification = 0;
    *patch        = 0;

    if (*buf == '.')
      {
	++buf;
	*modification = (int) strtoul (buf, &buf, 10);
	if (*buf == '.')
	  {
	    ++buf;
	    *patch = (int) strtoul (buf, &buf, 10);
	  }
      }

    if (*buf != '\0')
      {
	*version      =
	*modification =
	*patch        = 0;
      }

    delete [] buffer;
  }