Exemplo n.º 1
0
Arquivo: core.cpp Projeto: Pik-9/qTox
/**
 * @brief Get the names of the peers of a group
 */
QList<QString> Core::getGroupPeerNames(int groupId) const
{
    QList<QString> names;
    if (!tox)
    {
        qWarning() << "Can't get group peer names, tox is null";
        return names;
    }

    int result = getGroupNumberPeers(groupId);
    if (result < 0)
    {
        qWarning() << "getGroupPeerNames: Unable to get number of peers";
        return names;
    }
    uint16_t nPeers = static_cast<uint16_t>(result);

    std::unique_ptr<uint8_t[][TOX_MAX_NAME_LENGTH]> namesArray{new uint8_t[nPeers][TOX_MAX_NAME_LENGTH]};
    std::unique_ptr<uint16_t[]> lengths{new uint16_t[nPeers]};
    result = tox_group_get_names(tox, groupId, namesArray.get(), lengths.get(), nPeers);
    if (result != nPeers)
    {
        qWarning() << "getGroupPeerNames: Unexpected tox_group_get_names result";
        return names;
    }
    for (uint16_t i=0; i<nPeers; i++)
       names.push_back(CString::toString(namesArray[i], lengths[i]));

    return names;
}
Exemplo n.º 2
0
void print_groupchatpeers(Tox *m, int groupnumber)
{
    int num = tox_group_number_peers(m, groupnumber);

    if (num < 0)
        return;

    if (!num) {
        new_lines("[g]+ no peers left in group.");
        return;
    }

    uint8_t names[num][TOX_MAX_NAME_LENGTH];
    uint16_t lengths[num];
    tox_group_get_names(m, groupnumber, names, lengths, num);
    int i;
    char numstr[16];
    char header[] = "[g]+ ";
    size_t header_len = strlen(header);
    char msg[STRING_LENGTH];
    strcpy(msg, header);
    size_t len_total = header_len;

    for (i = 0; i < num; ++i) {
        size_t len_name = lengths[i];
        size_t len_num = sprintf(numstr, "%i: ", i);

        if (len_num + len_name + len_total + 3 >= STRING_LENGTH) {
            new_lines_mark(msg, 1);

            strcpy(msg, header);
            len_total = header_len;
        }

        strcpy(msg + len_total, numstr);
        len_total += len_num;
        memcpy(msg + len_total, (char *)names[i], len_name);
        len_total += len_name;

        if (i < num - 1) {
            strcpy(msg + len_total, "|");
            len_total++;
        }
    }

    new_lines_mark(msg, 1);
}
Exemplo n.º 3
0
QList<QString> Core::getGroupPeerNames(int groupId) const
{
    QList<QString> names;
    int nPeers = getGroupNumberPeers(groupId);
    if (nPeers == -1)
    {
        qWarning() << "Core::getGroupPeerNames: Unable to get number of peers";
        return names;
    }
    uint8_t namesArray[nPeers][TOX_MAX_NAME_LENGTH];
    uint16_t* lengths = new uint16_t[nPeers];
    int result = tox_group_get_names(tox, groupId, namesArray, lengths, nPeers);
    if (result != nPeers)
    {
        qWarning() << "Core::getGroupPeerNames: Unexpected result";
        return names;
    }
    for (int i=0; i<nPeers; i++)
       names.push_back(CString::toString(namesArray[i], lengths[i]));
    return names;
}
Exemplo n.º 4
0
static void groupchat_onGroupNamelistChange(ToxWindow *self, Tox *m, int groupnum, int peernum, uint8_t change)
{
    if (self->num != groupnum)
        return;

    if (groupnum > max_groupchat_index)
        return;

    groupchats[groupnum].num_peers = tox_group_number_peers(m, groupnum);
    int num_peers = groupchats[groupnum].num_peers;

    if (peernum > num_peers)
        return;

    /* get old peer name before updating name list */
    uint8_t oldpeername[TOX_MAX_NAME_LENGTH];

    if (change != TOX_CHAT_CHANGE_PEER_ADD) {
        memcpy(oldpeername, &groupchats[groupnum].oldpeer_names[peernum * TOX_MAX_NAME_LENGTH],
               sizeof(oldpeername));
        uint16_t old_n_len = groupchats[groupnum].oldpeer_name_lengths[peernum];
        oldpeername[old_n_len] = '\0';
    }

    /* Update name/len lists */
    uint8_t tmp_peerlist[num_peers][TOX_MAX_NAME_LENGTH];
    uint16_t tmp_peerlens[num_peers];

    if (tox_group_get_names(m, groupnum, tmp_peerlist, tmp_peerlens, num_peers) == -1) {
        memset(tmp_peerlist, 0, sizeof(tmp_peerlist));
        memset(tmp_peerlens, 0, sizeof(tmp_peerlens));
    }

    copy_peernames(groupnum, tmp_peerlist, tmp_peerlens, num_peers);

    /* get current peername then sort namelist */
    uint8_t peername[TOX_MAX_NAME_LENGTH];

    if (change != TOX_CHAT_CHANGE_PEER_DEL) {
        uint16_t n_len = groupchats[groupnum].peer_name_lengths[peernum];
        memcpy(peername, &groupchats[groupnum].peer_names[peernum * TOX_MAX_NAME_LENGTH], sizeof(peername));
        peername[n_len] = '\0';
    }

    qsort(groupchats[groupnum].peer_names, groupchats[groupnum].num_peers, TOX_MAX_NAME_LENGTH, qsort_strcasecmp_hlpr);

    ChatContext *ctx = self->chatwin;

    const char *event;
    char timefrmt[TIME_STR_SIZE];
    get_time_str(timefrmt, sizeof(timefrmt));

    switch (change) {
    case TOX_CHAT_CHANGE_PEER_ADD:
        if (!timed_out(groupchats[groupnum].start_time, GROUP_EVENT_WAIT))
            break;

        struct group_add_thrd *thrd = malloc(sizeof(struct group_add_thrd));
        thrd->m = m;
        thrd->peernum = peernum;
        thrd->groupnum = groupnum;
        thrd->self = self;
        thrd->timestamp = get_unix_time();

        if (pthread_attr_init(&thrd->attr) != 0) {
            free(thrd);
            return;
        }

        if (pthread_attr_setdetachstate(&thrd->attr, PTHREAD_CREATE_DETACHED) != 0) {
            pthread_attr_destroy(&thrd->attr);
            free(thrd);
            return;
        }

        if (pthread_create(&thrd->tid, &thrd->attr, group_add_wait, (void *) thrd) != 0) {
            pthread_attr_destroy(&thrd->attr);
            free(thrd);
            return;
        }

        break;

    case TOX_CHAT_CHANGE_PEER_DEL:
        event = "has left the room";
        line_info_add(self, timefrmt, (char *) oldpeername, NULL, DISCONNECTION, 0, RED, event);

        if (groupchats[self->num].side_pos > 0)
            --groupchats[self->num].side_pos;

        write_to_log(event, (char *) oldpeername, ctx->log, true);
        break;

    case TOX_CHAT_CHANGE_PEER_NAME:
        if (!timed_out(groupchats[self->num].start_time, GROUP_EVENT_WAIT))
            return;

        /* ignore initial name change (TODO: this is a bad way to do this) */
        if (strcmp((char *) oldpeername, DEFAULT_TOX_NAME) == 0)
            return;

        event = " is now known as ";
        line_info_add(self, timefrmt, (char *) oldpeername, (char *) peername, NAME_CHANGE, 0, 0, event);

        char tmp_event[TOXIC_MAX_NAME_LENGTH * 2 + 32];
        snprintf(tmp_event, sizeof(tmp_event), "is now known as %s", (char *) peername);
        write_to_log(tmp_event, (char *) oldpeername, ctx->log, true);
        break;
    }

    sound_notify(self, silent, NT_WNDALERT_2, NULL);
}