Ahogy azt megszokhattuk először is az új control karaktereit kell megrajzolnunk. A szokásos CHAREDIT programmal ezt megtehetjük, s az alábbi nyilakat kell megrajzolni:
 

Felfelé nyíl két karakterből: #212 és #183:	Felfelé nyíl a második karakter invertálása után:
Lefelé nyíl két karakterből: #213 és #184:	Lefelé nyíl a második karakter invertálása után:
Bal nyíl két karakterből: #217 és #21:	Bal nyíl a második karakter invertálása után:
Jobb nyíl két karakterből: #218 és #185:	Jobb nyíl a második karakter invertálása után:

 
Láthatjuk, hogy a nyilak két karakterből állnak a bal oldali részük keretkarakterből, hogy a 9. oszlopban megismételje a 8. oszlop beli pontokat. A nyíl jobb karaktere meg egy invertált karakterből áll, hogy a 9. oszlopban egy teljes csík látszódjék (Így nem lesz üres a 9. oszlopa a nyílnak, s illeszkedni fog a scrollbar többi részéhez. Figyelem nem a 8. Oszlop pontjait fogja a 9.-ben megismételni, hanem a teljes 9.-et fogja kigyújtani.) Megjegyezném, hogy most már a Norton Utilities felhasználói felületén túlnőttünk, hisz ott nincsen horizontális scrollbar. (A NU NCD programja használja egyedül a horizontális scrollbar-t, de az valami fertelmes, sima karakterekből van.)

Nézzük meg, hogyan kell módosítanunk a VIEWS unit forráskódját ahhoz, hogy szép saját scrollbar-jainkat használhassuk.

A Turbo Vision írói ötletes módon egy tömbbe rakták azokat a karaktereket melyekkel a scrollbar-t kiírják. Így a jobb nyíl ASCII kódját, majd a bal nyílét, stb. Persze ezek a sima DOS-os karakterek nem valami szépek, nem csoda, hisz nem erre lettek kitalálva. Épp ezért írjuk át. Mi is az eredetihez hasonlóan egy tömbbe rakjuk a karaktereket amikkel majd kiírjuk a scrollbar-t. A bökkenő az, hogy a TV által definiált ilyen tömb típus (TScrollChars) csak 5 karakteres nekünk meg 6 karakteres tömb kell lévén, hogy a fel és le nyilunk nem egy hanem két karakter széles. Így definiálhatunk egy új, saját típust legyen a változatosság kedvéért: TPCXScrollChars.

Majd ezt a tömböt saját scrollbar objektumunk Init-jében ahogy az eredeti TScrollBar-ban initializáljuk. Persze nem csak grafikus kinézetű karakterekkel töltünk fel egy tömböt, hanem meghagyjuk a sima text karakterekkel is mert lehet, hogy sima nem grafikus kinézetű módban akarjuk elindítani az applikációt. Így elkerülhetjük azt, hogy két külön scrollbar objektumot kelljen használni attól függően, hogy sima text, vagy grafikus látszatú text módban fut –e a programunk. Így a text módtól függően egy objektum fogja lekezelni a scrollbar-t.

Lássuk a saját scrollbar objektumunk init-jét:

constructor TPCXScrollBar.Init(var Bounds: TRect);
const
{ felb felj leb lej }
  GVChars: TPCXScrollChars = (#212, #183, #213, #184, GFrameEdgeL, GFrameEdgeR);
  GHChars: TPCXScrollChars = (#217, #21, #218, #185, #215, #215);
  VChars : TPCXScrollChars = (#30, #31, #177, #254, #178, #32); {Text, it's }
  HChars : TPCXScrollChars = (#17, #16, #177, #254, #178, #32); {the original}
begin
  TView.Init(Bounds);
  if IsPCXGraphCharsOn then TempB:=2 else TempB:=1;
  Value := 0;
  Min := 0;
  Max := 0;
  PgStep := 1;
  ArStep := 1;
  if Size.X = TempB then
  begin
    GrowMode := gfGrowLoX + gfGrowHiX + gfGrowHiY;
    if IsPCXGraphCharsOn then Chars := GVChars
                         else Chars := VChars;
    IsHorizontal:=False;
  end else
  begin
    GrowMode := gfGrowLoY + gfGrowHiX + gfGrowHiY;
    if IsPCXGraphCharsOn then Chars := GHChars
                         else Chars := HChars;
    IsHorizontal:=True;
  end;
end;

• Láthatjuk a deklaráltunk egy Grafikus horizontális és egy vertikális scrollbar-t, ill. a sima text horizontális és vertikális scrollbar-okat.
• A grafikus scrollbar tömbjében ilyen sorrendben vannak az átírt nyíl karakterek:
• Vertikális:

Felfelé nyíl bal majd jobb oldal,
Lefelé nyíl bal majd jobb oldali része,
A bal oldali keret karakter, s végül a
jobb oldali keretkarakter.
• Horizontális:

Balra nyíl – a nyíl feje, majd a nyíl szára,
Jobbra nyíl szára, majd a nyíl feje,
s végül kétszer a nyilakat összekötő karakter.
• A sima text tömb karakterei hasonlóan vannak felépítve, s megegyeznek az eredeti TV-ével, kiv., hogy a 6. Karakter egy plusz space.

• Meghívjuk az előd Init()-jét a Tview.Init()-et.
• Tudnunk kell azt, hogy az eredeti Turbo Vision úgy dönti el, hogy horizontális, vagy vertikális scrollbar kell –e, hogy ha: egy karakter széles a scrollbar akkor biztosan vertikális (gyk.: függőleges) ellenkező esetben horizontális (gyk.: vízszintes).
• Így megnézzük, hogy grafikus kinézetű karakterekkel dolgozik –e a program, ha igen:

És két karakter széles akkor grafikus vertikális scrollbar-t kell készíteni,
Ha szélesebb, mint két karakter akkor a felhasználó biztosan horizontális scrollbar-t akar kirajzolni, így azt kell majd kirajzolni.
• Ha sima text módban vagyunk és:

Egy karakter széles akkor vertikális kell,
Ellenkező esetben horizontális.
• A TempB: Byte objektumra lokális változó tartalmazza a text ill. grafikus text módhoz kötött scrollbar szélességet:

Sima Text mód: Egy karakter széles a veritkális scrollbar, míg
Grafikus Text mód: Két karakter széles a vertikális scrollbar.
(Ezt később még használjuk !)
• Így az if TempB then feltétel miatt eldől – text módtól függetlenül -, hogy vertikális, vagy horizontális scrollbar kell –e.
• Majd, hogy bejutottunk a megfelelő feltétel ágába, ott újra megvizsgáljuk, hogy milyen karaktereket kell átadni a scrollbar objektum Chars tömbjének, melyből az objektum a későbbiek során dolgozni fog. (Ezt használja majd a Draw metódus.)
• Ha a vertikális ágba jutottunk (Size.X = TempB) akkor az IsHorizontal: Boolean változót False-ra állítjuk, ha a horizontális (else) ágba kerültünk akkor True-ra állítjuk. Ez egy általam újonnan deklarált objektumra lokális változó mely könnyebbé teszi később a kirajzolást.
• Van amit idáig még elhallgattam, s ez a GrowMode.

Ez megadja, hogy az adott view (itt a scrollbar) hogyan viselkedjen amikor a tulajdonos group – view (itt az ablak) átméreteződik. A GrowMode bit-ek lehetővé teszik, hogy a view egyik csücskét a tulajdonos valamelyik oldalához rögzítsük. Ezen csücsök nem mozdul el a méretezéskor, míg a többi elmozdul s lehetővé válik a view méretezése persze megadható, hogy csak X vagy Y irányban méreteződjön. Erről már volt valamikor szó, de azért újra átvesszük, mert már biztosan elfelejtettétek mi is volt a PC-X User 3. vagy 4. számában.

• LoX – left side-ot Ř bal oldalt,
• LoY – top side-ot Ř a view tetejét,
• HiX – right side-ot Ř a view bal oldalát, míg a
• HiY – bottom side-ot Ř a view alját jelenti a viszonyításkor.

• Vertikális scrollbar:

GrowMode := gfGrowLoX + gfGrowHiX + gfGrowHiY;
Ř A scrollbar bal oldala a view jobb oldalához képest nem mozdul el,
Ř A scrollbar jobb oldala és az owner jobb oldala közötti távolság állandó.
Így e kettő eredménye képen a vertikális scrollbar nem nyúlik vizsintes irányban.
Ř Az utolsó gfXXX paraméter megadja, hogy a scrollbar alja és az owner alja közötti távolság állandó maradjon ami a scrollbar függőleges méretezhetőségét eredményezi.
• Horizontális scrollbar:

GrowMode := gfGrowLoY + gfGrowHiX + gfGrowHiY;
Ř gfGrowLoY + gfGrowHiY: a scrollbar tetejének távolsága állandó marad az owner aljához képest, és a scrollbar alja is állandó távolságban marad az owner aljától,
Ř gfGrowHiX: a scrollbar jobb széle állandó távolságra marad az owner széléhez képest, ami azt eredményezi, hogy a scrollbar vízszintesen együtt méreteződik az owner-rel.
• Nos a lényeggel meg volnánk, persze még beállíthatunk olyan apróságokat, mint az:

aktuális értéke a scrollbar-nal = Value
a Min(imum) és Max(imum) értékeket, ill. a
PgStep – a PgDown – PgUp-ra hozzáadandó ill. levonandó érték, s hasonlóan az ArStep is.

Nyílván való, hogy ahol az eredeti TScrollbar megvizsgálja, hogy horizontális, vagy vertikális –e a scrollbar ott módosítani kell, mert a régi feltétel ez volt: Size.X = 1. Ez ugye megváltozott hisz lehet kettő széles scrollbar s még akkor is vertikális, csak grafikus kinézetű. (hisz az eredeti objektumban minden ami nem egy széles volt az horizontális volt.) Így a Size.X = 1 -eket Size.X = TempB-re kell átállítani. (Persze bizonyos helyeken fel lehetne használni az IsHorizontal: Boolean logikai változót, de nem tesszük mert inkább megőrizzük a régivel a látszat szerinti kompatibilitást.) Nos lássuk, mit kell átalakítani. Első sorban a HandleEvent()-öt ami jelentős számban használja ezen vizsgálatot. Így az új objektumunk HandleEvent()-je így néz ki:

procedure TPCXScrollBar.HandleEvent(var Event: TEvent);
{...}
function GetPartCode: Integer;
var
  Mark, Part: Integer;
begin
  Part := -1;
  if Extent.Contains(Mouse) then
  begin
    if Size.X = TempB then Mark := Mouse.Y else Mark := Mouse.X;
    if Mark = P then Part := sbIndicator else
    begin
      if Mark < TempB then Part := sbLeftArrow else
      if Mark < P then Part := sbPageLeft else
      if Mark < S then Part := sbPageRight else
      Part := sbRightArrow;
      if Size.X = TempB then Inc(Part, 4);
    end;
  end;
  GetPartCode := Part;
end;

{ ... }

begin
  TView.HandleEvent(Event);
  case Event.What of
  evMouseDown:
  begin
    { ... }
    if ClickPart <> sbIndicator then
    begin
      { ... }
      end else
      begin
        repeat
          MakeLocal(Event.Where, Mouse);
          Tracking := Extent.Contains(Mouse);
          if Tracking then
          begin
            if Size.X = TempB then I := Mouse.Y else I := Mouse.X;
          end;
          { ... ... ... ... ... ...}
        end;
      end;

Hasonlóan ki kell cserélni a GetSize() függvényben is:

function TPCXScrollBar.GetSize: Integer;
var
  S: Integer;
begin
  if Size.X = TempB then S := Size.Y else S := Size.X;
  if S < 2+TempB then GetSize := 2+TempB else GetSize := S;
end;

Nos jöjjön az objektum lelke a Draw() és DrawPos() metódus, melyet nem véletlenül hagytam a végére. A Draw() metódust ugyanúgy kell az objektumban implementálni ahogy elődjében. (Azért kell deklarálni, mert a DrawPos() rutin privát, s nem virtuális. Így az általunk írt DrawPos() metódus nem tud visszahatni ősének Draw() metódusára.) Lássuk a DrawPos()-t:

procedure TPCXScrollBar.DrawPos(Pos: Integer);
var
  S: Integer;
  B: TDrawBuffer;
  i: Word;
begin
  if IsPCXGraphCharsOn then
  begin
    if Not IsHorizontal then
    begin
      S := GetSize - 1;
      MoveCStr(B[0], Chars[0], GetColor(2));
      MoveCStr(B[1], Chars[1], SwapHighAndLowAreaOfByte(GetColor(2)));
      if Max = Min then
      begin
        i:=0;
        while i<(S*2)-1 do
        begin
          Inc(I,2);
          MoveCStr(B[i], ''+Chars[4]+Chars[5]+'', GetColor(1));
        end;
      end
      else
      begin
          i:=0;
          while i<(S*2)-1 do
          begin
            Inc(i,2);
            MoveCStr(B[i], ''+Chars[4]+Chars[5]+'', GetColor(3));
            MoveCStr(B[Pos*2], ''+Chars[4]+Chars[5]+'', GetColor(4));
          end;
      end;
      MoveCStr(B[S*2], Chars[2], GetColor(2));
      MoveCStr(B[(S*2)+1], Chars[3], SwapHighAndLowAreaOfByte(GetColor(2)));
      WriteBuf(0, 0, Size.X, Size.Y, B);
    end
    else
    begin
      S := GetSize - 1;
      if Pos=1 then Inc(Pos);
      if Pos+1=S then Pos:=S-3;
      MoveCStr(B[0], Chars[0], GetColor(2));
      MoveCStr(B[1], Chars[1], SwapHighAndLowAreaOfByte(GetColor(2)));
      if Max = Min then
        MoveChar(B[2], Chars[4], GetColor(1), S - 2)
      else
      begin
        MoveChar(B[2], Chars[4], GetColor(3), S - 2);
        MoveCStr(B[Pos], Chars[5]+Chars[5], GetColor(4));
      end;
      MoveCStr(B[S-1], Chars[2], GetColor(2));
      MoveCStr(B[S], Chars[3], SwapHighAndLowAreaOfByte(GetColor(2)));
      WriteBuf(0, 0, Size.X, Size.Y, B);
    end;
  end
  else
  begin
    S := GetSize - 1;
    MoveChar(B[0], Chars[0], GetColor(2), 1);
    if Max = Min then
      MoveChar(B[1], Chars[4], GetColor(1), S - 1)
    else
    begin
      MoveChar(B[1], Chars[2], GetColor(1), S - 1);
      MoveChar(B[Pos], Chars[3], GetColor(3), 1);
    end;
    MoveChar(B[S], Chars[1], GetColor(2), 1);
    WriteBuf(0, 0, Size.X, Size.Y, B);
  end;
  Message(Application, evCommand, cmMouseChanged, @Self);
end;
 
Hogyan is működik ?

• Először megnézzük, hogy "grafikus textmódban" vagyunk –e ? Ha igen akkor ügyelnünk kell arra, hogy megfelelően írjuk ki a scrollbar-t, hisz már más a vastagsága is. Tovább lépünk:
• Megvizsgáljuk, hogy vertikális –e ha igen akkor ezzel foglalkozunk először:
• Az S lokális változóba lementjük a hosszát a scrollbar-nak.
• Majd az első két karaktert a kiírató tömbbe mozgatjuk. Ez vertikális scrollbar-nál a felfelé nyíl feje. Ezt a scrollbar palettájának 2. Indexű elemének színével kívánjuk kiírni.
• Majd a második karaktert a felfelé nyíl szárát kell a kiírató bufferbe rakni. VIGYÁZAT: ez invertálva adtuk meg, így fordított színekben kell kiírni, hogy megkapjuk a kívántat.

( Invertbe letárolt karaktert akkor kapunk meg szépen – ahogy látni akarjuk – a képernyőn, ha az előtér és háttér színeket felcseréljük. Magyarul exchange-eljük (de mondhatnók’ swapping) a szín attribútum alsó és felső 4 bit-ét. De akinek ez meredek lett volna – avagy ezen tempó deriváltja túl nagy neki ezen intervallumon – az nézze meg az előző számot, mert ott részletesen elgagyogtam minden ide tartozó fortélyt. )
Nos a második karaktert benyomjuk a bufferbe, s a swappolt színt adjuk meg attribútumnak.
• Ezek után két lehetőség áll előttünk, hogy a scrollbar Minimuma és Maximuma egyenlő ekkor nem kell kiírni a scrollbar gördítő sávjában azt a kis négyzetet, így egyszerűsödik a helyzet, s csak egy sima ciklus kell ami a két nyíl közötti gördítősáv karaktereket a bufferbe rakja, ez:

 
while i<(S*2)-1 do
begin
  Inc(I,2);
  MoveCStr(B[i], ''+Chars[4]+Chars[5]+'', GetColor(1));
end;
 
• Nos ha van határozott kezdőérték – minimum és végérték – maximum akkor a kiírás csak annyival lesz bonyolultabb, hogy a Pos-helyre (ezt a paramétert kapja meg függvényünk, hogy tudja, hova kell a gördítősávban a kis négyzetet kirajzolni – ha kell) kell kirajzolni azt a kis négyzetet, amit drag-golva és függőlegesen mozgatva scroll-ozni tudunk. Lássuk ezt a feltételi (else) ágat:

while i<(S*2)-1 do
begin
  Inc(i,2);
  MoveCStr(B[i], ''+Chars[4]+Chars[5]+'', GetColor(3));
  MoveCStr(B[Pos*2], ''+Chars[4]+Chars[5]+'', GetColor(4));
end; 
 

• Ez teljesen nyilvánvaló, hogy a Pos kétszeresére az összekötő karaktereket más háttérszínnel kiírva kapjuk meg a négyzetet. (Ha így kicsit furcsán hangozna, csak meg kell nézni a példaprogramot.) Persze azért kétszeres, mert a mi új scrollbar-unk két karakter széles nem úgy, mint elődje, s így a Pos-t 2-vel szorozva rakja jó helyre.
• Majd végül kiírjuk a lefelényíl szárát, majd a lefelé nyíl fejét invertálva. Végül az elkészített buffert a képernyőre iratjuk a rég ismert paranccsal. Lássuk a megvalósítást:

MoveCStr(B[S*2], Chars[2], GetColor(2));
MoveCStr(B[(S*2)+1], Chars[3], SwapHighAndLowAreaOfByte(GetColor(2)));
WriteBuf(0, 0, Size.X, Size.Y, B);
 

• Vertikális scrollbar forráskódunk végére értünk, innen már a procedure végére ugrik.

Lássuk a horizontális scrollbar megvalósítását, mely még egyszerűbb lesz:
• A Pos értéket beállítjuk helyesen, nehogy kilógjon a négyzetecske.
• Majd a bufferbe írjuk a most már megszokott módon a bal nyílfejét és szárát:

MoveCStr(B[0], Chars[0], GetColor(2));
MoveCStr(B[1], Chars[1], SwapHighAndLowAreaOfByte(GetColor(2)));
 

• Ezek után megvizsgáljuk, hogy Max egyenlő –e Min-nel, ha egyenlő azt jelenti nem kell a scrollbar-nak a négyzetecske, így egyszerűen egy sor lesz ami a bufferbe írja a kiírandó karaktereket:

if Max = Min then
  MoveChar(B[2], Chars[4], GetColor(1), S - 2)
else
 

• Ez logikus, hiszen kihasználhatjuk a MoveChar() azon tulajdonságát, hogy utolsó paraméterben megadhatjuk, hogy mennyiszer írja a bufferbe az előzőekben megadott karakter(eket).
• Ezután az else ág jön avagy ha kell az ominózus négyzetecske:

begin
  MoveChar(B[2], Chars[4], GetColor(3), S - 2);
  MoveCStr(B[Pos], Chars[5]+Chars[5], GetColor(4));
end;
 

• Ez se bonyolultabb, az első sor megegyezik az előző ágéval, majd a második MoveCStr() pedig a fentiekben jól beállított Pos helyre rakja a két karakter széles oly sokat emlegetett négyzetecskénket.
• S végül a jobb nyíl bufferbe rakása, és a képernyőre írás:

MoveCStr(B[S-1], Chars[2], GetColor(2));
MoveCStr(B[S], Chars[3], SwapHighAndLowAreaOfByte(GetColor(2)));
WriteBuf(0, 0, Size.X, Size.Y, B);
 

• Nos a "grafikus scrollbar-ral" végeztünk is, jön az eredeti TV-s, text. Ez még egyszer?bb, hisz egy féle képen lekezelhetjük a horizontális és vertikálisat is. Tesszük ezt úgy ahogy a Borland is tette. Fent a forráskód.

(Nem magyarázom el, hisz ugyanaz, mint amit idáig elmagyaráztam csak egyszer?bb.)

Egy kérdés érdekel valakit a C++ objektum orientáltsága? Mert ha igen akkor arról beszélhetünk a TV-átírás után. Akit érdekel, eresszen el egy egysoros levelecskét a PC-XUser@FREEMAIL.C3.HU-ra.