Moderators: Hacker, Stefan2, white
Code: Select all
/*** Erstellen Sortierbyte nach Uservorgaben **DCL**/
typedef class SortBits
{ // --friends
//- Fields
private:
char xTable[256];
public:
//-Structors
SortBits();
//-Operators
//-Methods
public:
/** SetSortOrder :: Sortierordnung festlegen *** DCL **/
char SetSortOrder ( // Sortierordnung festlegen
const char* WantedOrder // Gewünschte Sortierfolge
);
/** TranslateByte :: Byte umsetzen *** DCL **/
char TranslateByte ( // Byte umsetzen
const char ToTranslate // umzusetzendes Attribute-Byte
);
} SortBits; //! Erstellen Sortierbyte nach Uservorgaben
/** SortBits::SetSortOrder (Sortierordnung festlegen) *** BEG **/
char SortBits::SetSortOrder ( // Sortierordnung festlegen
const char* WantedOrder // Gewünschte Sortierfolge
) { // Sortierordnung festlegen
char RC_Wert; // Returnwert
int i,j;
char Tab26[26]; /* Sortiereingaben in Alpha-Folge */
char TabAtt[8]; /* Angaben pro Attribut */
char TabRest[8]; /* Restattribute */
char TabMask[8]; /* Maskenbits */
char Order;
//--- Code (no exceptions)
memset(Tab26,0,26);
Order=0;
RC_Wert=0;
for (i=0; // Alle Usereingaben
i<8;
i++) { // Alle Usereingaben
if(!WantedOrder[i]) { // String zu Ende
return(0xFF); /* Zu wenig Zeichen */
}; // String zu Ende
char Letter=WantedOrder[i];
if(Letter>='A' && Letter<='Z') { // Grossbuchstabe
if(Tab26[Letter-'A']) { // Bereits besetzt
return(Letter); /* Doppelt besetzt */
}; // Bereits besetzt
Tab26[Letter-'A']=i+17; /* Invers-Sortierung */
} // Grossbuchstabe
elif(Letter>='a' && Letter<='z') { // Kleinbuchstabe
if(Tab26[Letter-'a']) { // Bereits besetzt
return(Letter);
}; // Bereits besetzt
Tab26[Letter-'a']=i+1; /* Standard-Sortierung */
} // Kleinbuchstabe
else { // NOT Grossbuchstabe
if(!strchr("01 ",Letter)) { // Kein erlaubtes Zeichen
return(Letter);
}; // Kein erlaubtes Zeichen
}; // NOT Grossbuchstabe
}; // Alle Usereingaben
/* In Tab26 stehen nun die Sortpositionen */
for (j=0; // Prefill
j<8;
j++) { // Prefill
TabRest[j]=j+1;
}; // Prefill
j=0;
for (i=0; // Komprimieren
i<26;
i++) { // Komprimieren
if(Tab26[i]) { // Eintrag vorhanden
char Swap=Tab26[i] & 0x0F;
TabAtt[j]=Tab26[i];
TabRest[Swap-1]=0;
j++;
}; // Eintrag vorhanden
}; // Komprimieren
for (i=0; // Rest übertragen
i<8;
i++) { // Rest übertragen
if(TabRest[i]) { // Rest vorhanden
TabAtt[j++]=TabRest[i];
}; // Rest vorhanden
}; // Rest übertragen
/* Maskenbits erzeugen */
for (i=0; // Alle Sortbytes
i<8;
i++) { // Alle Sortbytes
int Shift=TabAtt[i] & 0x0F;
int Wert=0x100>>Shift;
TabMask[i]=Wert;
}; // Alle Sortbytes
/* Generierung der xLate-Tabelle */
for (i=0; // Alle Einträge
i<256;
i++) { // Alle Einträge
char xx=0;
char TestBit=0x80;
for (j=0; // Bits abarbeiten
j<8;
j++) { // Bits abarbeiten
if((i&TestBit) && !(TabAtt[j]&0x10)
||
!(i&TestBit) && (TabAtt[j]&0x10)
) { // Bit ohne Inversion
xx|=TabMask[j];
} // Bit ohne Inversion
TestBit>>=1;
}; // Bits abarbeiten
xTable[xx]=i;
}; // Alle Einträge
return(RC_Wert);
}; // Sortierordnung festlegen
/** SortBits::SetSortOrder (Sortierordnung festlegen) *** END **/
/** SortBits::TranslateByte (Byte umsetzen) *** BEG **/
char SortBits::TranslateByte ( // Byte umsetzen
const char ToTranslate // umzusetzendes Attribute-Byte
) { // Byte umsetzen
//--- Code (no exceptions)
return(xTable[ToTranslate]);
}; // Byte umsetzen
/** SortBits::TranslateByte (Byte umsetzen) *** END **/
SortBits::SortBits( // Default-Constructor
) {
int i;
for (i=0; // FOR_@@134
i<256;
i++) { // FOR_@@134
xTable[i]=i;
}; // FOR_@@134
}; // Default-Constructor
Code: Select all
/** TestTranslate (Testfunktion) *** BEG **/
static void TestTranslate ( // Testfunktion
const char* UserOrder // Gewünschte Sortierfolge
) { // Testfunktion
SortBits MeineBits;
char xx;
int i,j;
//--- Code (no exceptions)
printf("\nSortorder: (%s)=\n",UserOrder);
xx=MeineBits.SetSortOrder(UserOrder);
if(xx) { // Ging was schief...
printf("Letter=%c (%02X)\n",xx,xx);
return;
}; // Ging was schief...
xx=0;
for (i=0; // Left nibble
i<16;
i++) { // Left nibble
printf("%X*->:",i);
for (j=0; // Right nibble
j<16;
j++) { // Right nibble
printf(" %02X",MeineBits.TranslateByte(xx));
xx++;
}; // Right nibble
printf("\n");
}; // Left nibble
}; // Testfunktion
/** TestTranslate (Testfunktion) *** END **/
/*** Hauptfunktion ***/
int main(
int argc // Anzahl Argumente
, const char** argv // Argumentenliste
, const char** arge // Environmentliste
) {
int RC=0; // Returncode
//--- Code
TestTranslate(" a"); // Zuerst 'gerade', dann 'ungerade' bytes
TestTranslate("A "); // Zuerst die 'obere', dann die 'untere' Hälfte
TestTranslate(" D b "); // Irgendwas gemischtes zum Prüfen...
TestTranslate("abCDefGH"); // Mixturen aus normal und inverted
TestTranslate("efGHABDC");
TestTranslate("efHGABDC");
TestTranslate("zrqomkji"); // Bits von rechts nach links spiegeln
TestTranslate("ZRQOMKJI"); // Wie oben und außerdem invertieren
TestTranslate("abcdijkl"); // Normale Sortfolge (alles unverändert)
TestTranslate("ABCDIJKL"); // Alles invertiert (umgekehrte Sortierung)
return(RC);
}; // main
Ich meinte eher das Extra-Handling, das in dieser nachprogrammierten ListView (THeaderClick) Komponente kein Klick auf der Attributspalte zugelassen wird. (oder ist es anders rum, das nur Events auf den anderen Spalten zugewiesen sind und standardmässig klein Klick aktiv ist?)norfie wrote:Ist eher historisch bedingt und es gibt keine EXTRA Behandlung.
Ich denke, es ist eher so, weil es kein ListView sondern eine ListBox ist und die Header sind AFAIK Christians eigene Komponenten (so einen Pfeil gibt es bei den Standardkomponenten soweit ich weiss nicht).(oder ist es anders rum, das nur Events auf den anderen Spalten zugewiesen sind und standardmässig klein Klick aktiv ist?)
Ja, aber TC ist in Delphi und nich in C geschrieben =)MikeTheGuru wrote: Die technische Umsetzung habe ich bereits gepostet
Das hoffe ich seit Ewigkeiten bei jedem ReleaseMikeTheGuru wrote: Hoffen wir, daß das in einer kommenden Release auch so eingebaut wird!
Die Frage ob es eine intuitive gibt oder nicht, finde ich eigentlich gar nicht wichtig.MikeTheGuru wrote:Ich gebe Ch.Ghisler recht: es gibt keine intuitive Sortlogik für Attribute.
