home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1997 May / Pcwk0597.iso / borland / cb / setup / cbuilder / data.z / COLORGRD.CPP < prev    next >
C/C++ Source or Header  |  1997-02-28  |  14KB  |  500 lines
  1. //---------------------------------------------------------------------------
  2. // Borland C++Builder
  3. // Copyright (c) 1987, 1997 Borland International Inc.  All Rights Reserved.
  4. //---------------------------------------------------------------------------
  5. #if !defined (REGISTER_ALL_CONTROLS)
  6.   #include  "colorgrd.h"
  7. #else
  8.   #include "source\colorgrd.h"
  9. #endif
  10.  
  11. //#pragma resource "*.res"   //IDE links .res automatically for components
  12.  
  13. namespace Colorgrd {
  14. void __fastcall Register()
  15. {
  16.   TComponentClass classes[1] = {__classid(TColorGrid)};
  17.   RegisterComponents("Samples", classes, 0);
  18. }
  19. }
  20.  
  21. __fastcall TColorGrid::TColorGrid(TComponent *AOwner):
  22.          TCustomControl( AOwner )
  23. {
  24.   ControlStyle = ControlStyle;// + [csOpaque]; // cbf
  25.   FGridOrdering = go4x4;
  26.   FNumXSquares = 4;
  27.   FNumYSquares = 4;
  28.   FForegroundEnabled = True;
  29.   FBackgroundEnabled = True;
  30.   Color = TColor(clBtnFace);   // cbf assinging int to Tcolor
  31.   Canvas->Brush->Style = bsSolid;
  32.   Canvas->Pen->Color = clBlack;
  33.   SetBounds(0, 0, 100, 100);
  34.   GetPaletteEntries(GetStockObject(DEFAULT_PALETTE), 0, NumPaletteEntries,
  35.   FPaletteEntries);
  36. }
  37.  
  38. void __fastcall TColorGrid::CreateWnd(void)
  39. {
  40.    TCustomControl::CreateWnd();
  41.    SetWindowLong(Handle, GWL_STYLE, GetWindowLong(Handle, GWL_STYLE) | WS_CLIPSIBLINGS);
  42. }
  43.  
  44. //class TempRect
  45. void __fastcall TColorGrid::DrawSquare(Integer Which, Boolean ShowSelector)
  46. {
  47.   Integer WinTop, WinLeft;
  48.   Integer PalIndex;
  49.   TRect CellRect;
  50.   if( Which >=0 && Which <= 15 )
  51.   {
  52.     if( Which < 8 )
  53.       PalIndex = Which;
  54.     else
  55.       PalIndex = Which + 4;
  56.     WinTop = ( Which/FNumXSquares ) * FCellYSize;
  57.     WinLeft = (Which % FNumXSquares) * FCellXSize;
  58.     CellRect = Bounds(WinLeft, WinTop, FCellXSize, FCellYSize);
  59.     if( Ctl3D ) {
  60.       Canvas->Pen->Color = TColor(clBtnFace);
  61.       Canvas->Rectangle(RECT(CellRect).left,
  62.                         RECT(CellRect).top,
  63.                         RECT(CellRect).right,
  64.                         RECT(CellRect).bottom);
  65.       InflateRect(&RECT(CellRect), -1, -1);
  66.       Extctrls::Frame3D(Canvas, CellRect, TColor(clBtnShadow), TColor(clBtnHighlight), 2);
  67.     }
  68.     else
  69.       Canvas->Pen->Color = TColor(clBlack);
  70.       TPaletteEntry temp = FPaletteEntries[PalIndex];
  71.       Canvas->Brush->Color = TColor(RGB( temp.peRed, temp.peGreen, temp.peBlue));
  72.       if( Ctl3D )
  73.         Canvas->Pen->Color = TColor(RGB(temp.peRed, temp.peGreen, temp.peBlue));
  74.     if( !ShowSelector )
  75.       Canvas->Rectangle(RECT(CellRect).left,
  76.                         RECT(CellRect).top,
  77.                         RECT(CellRect).right,
  78.                         RECT(CellRect).bottom);
  79.     else
  80.     {
  81.       if(Ctl3D)
  82.       {
  83.         Canvas->Rectangle(RECT(CellRect).left,
  84.                           RECT(CellRect).top,
  85.                           RECT(CellRect).right,
  86.                           RECT(CellRect).bottom);
  87.         InflateRect(&RECT(CellRect), -1, -1);
  88.         DrawFocusRect((HDC)Canvas->Handle, &RECT(CellRect));
  89.       }
  90.       else
  91.       {
  92.         Canvas->Pen->Color = clBlack;
  93.         Canvas->Pen->Mode = pmNot;
  94.         Canvas->Rectangle(RECT(CellRect).left,
  95.                           RECT(CellRect).top,
  96.                           RECT(CellRect).right,
  97.                           RECT(CellRect).bottom);
  98.         Canvas->Pen->Mode = pmCopy;
  99.         Canvas->Rectangle(RECT(CellRect).left +2,
  100.                           RECT(CellRect).top +2,
  101.                           RECT(CellRect).right -2,
  102.                           RECT(CellRect).bottom -2);
  103.       }
  104.     }
  105.   }
  106. }
  107.  
  108.  
  109.  
  110.  
  111. int TernaryOp( Boolean Test, Integer ResultTrue, Integer ResultFalse )
  112. {
  113.    int Result;
  114.    if( Test )
  115.      Result = ResultTrue;
  116.    else
  117.      Result = ResultFalse;
  118.    return Result;
  119. }
  120.  
  121.  
  122. #pragma warn -sig
  123. void __fastcall TColorGrid::DrawFgBg(void)
  124. {
  125.   TPaletteEntry TextColor;
  126.   Integer PalIndex;
  127.   AnsiString TheText;
  128.   Integer OldBkMode;
  129.   TRect R;
  130.  
  131.   OldBkMode = SetBkMode((HDC)Canvas->Handle, TRANSPARENT);
  132.   if( FForegroundEnabled )
  133.   {
  134.     if( (FForegroundIndex == FBackgroundIndex) && FBackgroundEnabled )
  135.       TheText = LoadStr(SFB);
  136.     else
  137.       TheText = LoadStr(SFG);
  138.     if( FForegroundIndex < 8 )
  139.       PalIndex = FForegroundIndex;
  140.     else
  141.       PalIndex = FForegroundIndex + 4;
  142.     TextColor = FPaletteEntries[PalIndex];
  143.     TextColor.peRed = TernaryOp(TextColor.peRed >= 0x80, 0, 0xFF);
  144.     TextColor.peGreen = TernaryOp(TextColor.peGreen >= 0x80, 0, 0xFF);
  145.     TextColor.peBlue = TernaryOp(TextColor.peBlue >= 0x80, 0, 0xFF);
  146.     Canvas->Font->Color = TColor(RGB(TextColor.peRed, TextColor.peGreen, TextColor.peBlue));
  147.  
  148.     R.Left = (FForegroundIndex % FNumXSquares) * FCellXSize;
  149.     R.Right = R.Left + FCellXSize;
  150.     R.Top = (FForegroundIndex / FNumXSquares) * FCellYSize;
  151.     R.Bottom = R.Top + FCellYSize;
  152.     DrawText((HDC)Canvas->Handle, PChar(TheText.c_str()), -1, &RECT(R),
  153.              DT_NOCLIP | DT_SINGLELINE | DT_CENTER | DT_VCENTER);
  154.   }
  155.   if( FBackgroundEnabled )
  156.   {
  157.     if( (FForegroundIndex == FBackgroundIndex) && FForegroundEnabled ) 
  158.       TheText = LoadStr(SFB);
  159.     else
  160.       TheText = LoadStr(SBG);
  161.     if( FBackgroundIndex < 8 ) 
  162.       PalIndex = FBackgroundIndex;
  163.     else
  164.       PalIndex = FBackgroundIndex + 4;
  165.  
  166.     TextColor = FPaletteEntries[PalIndex];
  167.     TextColor.peRed = TernaryOp(TextColor.peRed >= 0x80, 0, 0xFF);
  168.     TextColor.peGreen = TernaryOp(TextColor.peGreen >= 0x80, 0, 0xFF);
  169.     TextColor.peBlue = TernaryOp(TextColor.peBlue >= 0x80, 0, 0xFF);
  170.     Canvas->Font->Color = TColor(RGB(TextColor.peRed, TextColor.peGreen, TextColor.peBlue));
  171.     R.Left = (FBackgroundIndex % FNumXSquares) * FCellXSize;
  172.     R.Right = R.Left + FCellXSize;
  173.     R.Top = (FBackgroundIndex / FNumXSquares) * FCellYSize;
  174.     R.Bottom = R.Top + FCellYSize;
  175.     DrawText((HDC)Canvas->Handle, PChar(TheText.c_str()), -1, &RECT(R),
  176.              DT_NOCLIP | DT_SINGLELINE | DT_CENTER | DT_VCENTER);
  177.   }
  178.   SetBkMode((HDC)Canvas->Handle, OldBkMode);
  179. }
  180. #pragma warn .sig
  181.  
  182. void __fastcall TColorGrid::EnableForeground(Boolean Value)
  183. {
  184.   if( FForegroundEnabled == Value ) 
  185.      return ;
  186.   FForegroundEnabled = Value;
  187.   DrawSquare(FForegroundIndex, (FForegroundIndex == FSelection) && FHasFocus);
  188.   DrawFgBg();
  189. }
  190.  
  191.  
  192.  
  193. void __fastcall TColorGrid::EnableBackground(Boolean Value)
  194. {
  195.   if( FBackgroundEnabled == Value ) 
  196.        return;
  197.   FBackgroundEnabled = Value;
  198.   DrawSquare(FBackgroundIndex, (FBackgroundIndex == FSelection) && FHasFocus);
  199.   DrawFgBg();
  200. }
  201.  
  202.  
  203.  
  204. TColor __fastcall TColorGrid::GetForegroundColor(void)
  205. {
  206.   Integer PalIndex;
  207.   if( FForegroundIndex < 8 )
  208.     PalIndex = FForegroundIndex;
  209.   else
  210.     PalIndex = FForegroundIndex + 4;
  211.     return TColor(RGB(FPaletteEntries[PalIndex].peRed,
  212.                   FPaletteEntries[PalIndex].peGreen,
  213.                   FPaletteEntries[PalIndex].peBlue) );
  214. }
  215.  
  216.  
  217. TColor __fastcall TColorGrid::GetBackgroundColor(void)
  218. {
  219.   Integer PalIndex;
  220.  
  221.   if( FBackgroundIndex < 8 ) 
  222.       PalIndex = FBackgroundIndex;
  223.   else PalIndex = FBackgroundIndex + 4;
  224.   return TColor( RGB(FPaletteEntries[PalIndex].peRed,
  225.                  FPaletteEntries[PalIndex].peGreen,
  226.                  FPaletteEntries[PalIndex].peBlue) );
  227. }
  228.  
  229.  
  230.  
  231.  
  232. void __fastcall TColorGrid::WMSetFocus(TWMSetFocus &Message)
  233. {
  234.   FHasFocus = True;
  235.   DrawSquare(FSelection, True);
  236.   DrawFgBg();
  237. }
  238.  
  239. void __fastcall TColorGrid::WMKillFocus(TWMKillFocus &Message)
  240. {
  241.   FHasFocus = False;
  242.   DrawSquare(FSelection, False);
  243.   DrawFgBg();
  244. }
  245.  
  246.  
  247.  
  248. void __fastcall TColorGrid::KeyDown(Word &Key,  TShiftState Shift)
  249. {
  250.   Integer NewSelection;
  251.   Integer Range;
  252.   TCustomControl::KeyDown(Key, Shift);
  253.   NewSelection = FSelection;
  254.   Range = FNumXSquares * FNumYSquares;
  255.   switch( Key )
  256.   {
  257.      case 0x46:
  258.      case 0x66:
  259.         if( !FForegroundEnabled && FClickEnablesColor ) {
  260.           FForegroundEnabled = True;
  261.           DrawSquare(FForegroundIndex, (FForegroundIndex == FSelection) && FHasFocus);
  262.           FForegroundIndex = -1;
  263.         }
  264.         SetForegroundIndex(NewSelection);
  265.         SetSelection(NewSelection);
  266.         Click();
  267.         break;
  268.       case 0x42:
  269.       case 0x62:
  270.           if( !FBackgroundEnabled && FClickEnablesColor ) {
  271.             FBackgroundEnabled = True;
  272.             DrawSquare(FBackgroundIndex, (FBackgroundIndex == FSelection) && FHasFocus);
  273.             FBackgroundIndex = -1;
  274.           }
  275.           SetBackgroundIndex(NewSelection);
  276.           SetSelection(NewSelection);
  277.           Click();
  278.           break;
  279.     case VK_HOME:
  280.         NewSelection = 0;
  281.         break;
  282.     case VK_UP:
  283.       if( FSelection >= FNumXSquares )
  284.         NewSelection = FSelection - FNumXSquares;
  285.       else
  286.         if( FSelection != 0 )
  287.           NewSelection = Range - FNumXSquares + FSelection - 1;
  288.         else
  289.           NewSelection = Range - 1;
  290.       break;
  291.     case VK_LEFT:
  292.        if( FSelection !=  0 )
  293.          NewSelection = FSelection - 1;
  294.        else
  295.          NewSelection = Range - 1;
  296.        break;
  297.     case VK_DOWN:
  298.        if( FSelection + FNumXSquares < Range )
  299.         NewSelection = FSelection + FNumXSquares;
  300.        else
  301.          if( FSelection != Range - 1 )
  302.            NewSelection = FSelection % FNumXSquares + 1;
  303.          else
  304.            NewSelection = 0;
  305.       break;
  306.     case VK_SPACE:
  307.     case VK_RIGHT:
  308.       if( FSelection != Range - 1 )
  309.         NewSelection = FSelection + 1;
  310.       else
  311.         NewSelection = 0;
  312.       break;
  313.     case VK_END:
  314.        NewSelection = Range - 1;
  315.         break;
  316.     default:
  317.     TCustomControl::KeyDown(Key, Shift);
  318.     return;
  319.   }  //end switch
  320.   Key = 0;
  321.   if( FSelection != NewSelection )
  322.      SetSelection(NewSelection);
  323.  }
  324.  
  325.  
  326. void __fastcall TColorGrid::WMGetDlgCode(TWMNoParams &Message)
  327. {
  328.   Message.Result = DLGC_WANTARROWS + DLGC_WANTCHARS;
  329. }
  330.  
  331.  
  332.  
  333. void __fastcall TColorGrid::WMSize(TWMSize &Message)
  334. {
  335.   UpdateCellSizes(False);
  336. }
  337.  
  338. void __fastcall TColorGrid::CMCtl3DChanged(TMessage &Message)
  339. {
  340.   Invalidate();
  341. }
  342.  
  343. void __fastcall TColorGrid::MouseDown(TMouseButton Button,  TShiftState Shift, Integer X, Integer Y)
  344. {
  345.   Integer Square;
  346.   TCustomControl::MouseDown(Button, Shift, X, Y);
  347.   FButton = Button;
  348.   FButtonDown = True;
  349.   Square = SquareFromPos(X, Y);
  350.   if( Button == mbLeft ){
  351.     if( !FForegroundEnabled && FClickEnablesColor ){
  352.       FForegroundEnabled = True;
  353.       DrawSquare(FForegroundIndex, (FForegroundIndex == FSelection) && FHasFocus );
  354.       FForegroundIndex = -1;
  355.     }
  356.     SetForegroundIndex(Square);
  357.   }
  358.   else{
  359.     MouseCapture = True;
  360.     if( !FBackgroundEnabled && FClickEnablesColor ) {
  361.       FBackgroundEnabled = True;
  362.       DrawSquare(FBackgroundIndex, (FBackgroundIndex == FSelection) && FHasFocus);
  363.       FBackgroundIndex = -1;
  364.     }
  365.     SetBackgroundIndex(Square);
  366.   }
  367.   SetSelection(Square);
  368.   if( TabStop )
  369.       SetFocus();
  370. }
  371.  
  372.  
  373. void __fastcall TColorGrid::MouseMove( TShiftState Shift, Integer X, Integer Y)
  374. {
  375.   Integer Square;
  376.  
  377.   TCustomControl::MouseMove(Shift, X, Y);
  378.   if( FButtonDown ){
  379.     Square = SquareFromPos(X, Y);
  380.     if( FButton == mbLeft )
  381.       SetForegroundIndex(Square);
  382.     else
  383.       SetBackgroundIndex(Square);
  384.     SetSelection(Square);
  385.   }
  386. }
  387.  
  388.  
  389. void __fastcall TColorGrid::MouseUp(TMouseButton Button,  TShiftState Shift, Integer X, Integer Y)
  390. {
  391.   TCustomControl::MouseUp(Button, Shift, X, Y);
  392.   FButtonDown = False;
  393.   if( FButton == mbRight )
  394.      MouseCapture = False;
  395.  }
  396.  
  397.  
  398.  
  399. void __fastcall TColorGrid::Paint(void)
  400. {
  401.  Integer Row, Col, wEntryIndex;
  402.  Canvas->Font = Font;
  403.  for( Row = 0; Row < FNumYSquares; Row++ )
  404.       for( Col = 0; Col < FNumXSquares; Col++ )
  405.       {
  406.        wEntryIndex = Row * FNumXSquares + Col;
  407.        DrawSquare(wEntryIndex, False);
  408.       }
  409.   DrawSquare(FSelection, FHasFocus);
  410.   DrawFgBg();
  411. }
  412.  
  413.  
  414. void __fastcall TColorGrid::SetBackgroundIndex(Integer Value)
  415. {
  416.   if( (FBackgroundIndex != Value) && FBackgroundEnabled )
  417.   {
  418.     DrawSquare(FBackgroundIndex, (FBackgroundIndex == FSelection) && FHasFocus);
  419.     FBackgroundIndex = Value;
  420.     if( FBackgroundIndex == FForegroundIndex )
  421.       DrawSquare(FBackgroundIndex, (FBackgroundIndex == FSelection) && FHasFocus);
  422.     DrawFgBg();
  423.     Change();
  424.   }
  425. }
  426.  
  427.  
  428.  
  429. void __fastcall TColorGrid::SetForegroundIndex(Integer Value)
  430. {
  431.   if( (FForegroundIndex != Value) && FForegroundEnabled  )
  432.   {
  433.     DrawSquare(FForegroundIndex, (FForegroundIndex == FSelection) && FHasFocus);
  434.     FForegroundIndex = Value;
  435.     if( FForegroundIndex == FBackgroundIndex )
  436.       DrawSquare(FForegroundIndex, (FForegroundIndex == FSelection) && FHasFocus );
  437.     DrawFgBg();
  438.     Change();
  439.   }
  440. }
  441.  
  442.  
  443. void __fastcall TColorGrid::SetGridOrdering(TGridOrdering Value)
  444. {
  445.   if( FGridOrdering == Value  )
  446.        return;
  447.   FGridOrdering = Value;
  448.   FNumXSquares = 16 >> FGridOrdering;
  449.   FNumYSquares = 1 << FGridOrdering;
  450.   UpdateCellSizes(True);
  451. }
  452.  
  453. void __fastcall TColorGrid::SetSelection(Integer Value)
  454. {
  455.   if( FSelection == Value )
  456.     return;
  457.   DrawSquare(FSelection, False);
  458.   FSelection = Value;
  459.   DrawSquare(FSelection, FHasFocus);
  460.   DrawFgBg();
  461. }
  462.  
  463.  
  464. Integer __fastcall TColorGrid::SquareFromPos(Integer X, Integer Y)
  465. {
  466.   if( X > Width - 1 )
  467.      X = Width - 1;
  468.   else
  469.     if( X < 0 )
  470.       X = 0;
  471.   if( Y > Height - 1 )
  472.    Y = Height - 1;
  473.   else
  474.      if( Y < 0 )
  475.       Y = 0;
  476.   return( Y / FCellYSize * FNumXSquares + X / FCellXSize);
  477. }
  478.  
  479.  
  480. void __fastcall TColorGrid::UpdateCellSizes(Boolean DoRepaint)
  481. {
  482.   Integer NewWidth, NewHeight;
  483.   NewWidth = (Width / FNumXSquares) * FNumXSquares;
  484.   NewHeight = (Height / FNumYSquares) * FNumYSquares;
  485.   BoundsRect = Bounds(Left, Top, NewWidth, NewHeight);
  486.   FCellXSize = Width / FNumXSquares;
  487.   FCellYSize = Height / FNumYSquares;
  488.   if( DoRepaint )
  489.     Invalidate();
  490. }
  491.  
  492.  
  493. void __fastcall TColorGrid::Change(void)
  494. {
  495.   if( FOnChange != NULL )
  496.      FOnChange(this);
  497. }
  498.  
  499.  
  500.