Markus-Hermann's questions

Criei e preenchi um tkinter.Listbox. Agora tenho eventos que selecionarão o item no índice index. Assim:

listbox.selection_clear(0, tk.END)
listbox.select_set(index)

E funciona porque a entrada com índice indexé de fato selecionada.

No entanto, ao usar as teclas "tab" para navegar até outros widgets que também têm o poder de selecionar itens naquela caixa de listagem e, em seguida, retornar à caixa de listagem, há uma seleção de sombra , que parece não ser a âncora (pelo menos, listbox.selection_anchor(index) não resolveu o problema para mim) na seleção que estava ativa quando deixei o foco nela pela última vez listbox. Usar as teclas "para cima" e "para baixo" assumirá o controle da seleção ativa. No entanto, elas não começarão na seleção correta ( 010_adfno exemplo abaixo), mas naquela sombra ( 007_adf) que só posso especificar mais detalhadamente fornecendo esta captura de tela:

Fig.: A "sombra" em questão está ao redor da entrada 007_adf. A seleção correta é 010.adf. Como sincronizar a sombra com a seleção correta?

Eu tenho uma grande variedade de um tipo de dados não assinado T*.

Deve ser convertido para unsigned char*valores de escala. Por exemplo, ao passar do unsigned short*intervalo unsigned char*de {0,..,255} deve ser mapeado para 0 e qualquer coisa em {65281,..,65535} para 255.

Ingenuamente, isso poderia ser feito em loop, usando algo como uma mudança de bit:

const T x = some_large_value;
unsigned char y = (x >> (8u * (sizeof(T) - 1u))); //<< Effectively a truncated "x/(256^{sizeof(t)-1})".

Mas me pergunto se existe uma maneira de evitar os for (..)envolvidos em tal solução. Sonhando com um parâmetro super-memcpyde suporte stepque pudesse ser usado assim:

// Intel processor. So I guess, little endian is needed. Assume there are N items.
const T* src = ..;
const unsigned char* src_uchar = reinterpret_cast<const unsigned char*>(src);
memcpy(dst_uchar, src_uchar + (sizeof(T) - 1u), N, step=sizeof(T)-1u);

Esse stepparâmetro putativo pularia tantos bytes após cada byte copiado. Infelizmente, é claro, isso não existe. No entanto, existe algum outro comando que permite isso ou seu efeito?

Apêndice: Adicionando um programa de demonstração funcional ao aprender uma solução

Um brilho de gratidão vai para pptaszni . No entanto, como ainda precisei de algum processamento para entender: Aqui está um pequeno programa de demonstração usando sua proposta. Ele converte de uma uint16matriz para uint8, reduzindo o intervalo de valores graças a uma mudança de bit. Também funciona em tipos assinados.

#include <algorithm>
#include <iostream>

using namespace std;

int main()
{
        // Input A and Output B.
        const unsigned short A[] = {60000u, 50000u, 30000u, 1000u, 500u, 300u, 200u};
              unsigned char  B[] = {    0u,     0u,     0u,    0u,   0u,   0u,   0u};

        // lambda expression.
        auto transformation = [](const unsigned short& elem)
                { return static_cast<unsigned char>(elem >> 8u * (sizeof(decltype(elem))-1)); };

        // Actual downsizing of UINT16 to UINT8.
        std::transform(A, A+7, B, transformation);

        // Show the results.
        for (size_t j=0; j<7; ++j)
                { cout << A[j] << " => " << ((unsigned short)B[j]) << endl; }
        return 0;
}

Saída:

60000 => 234
50000 => 195
30000 => 117
1000 => 3
500 => 1
300 => 1
200 => 0