lcdscreeneditor.pas.svn-base

LCDScreen is a couple of Delphi component which simulate a dot-LCD multilines screen. It is fully c

    inverse_charpos, blinking_charpos: Byte;
    FlagInverse: Boolean;
begin
  with LinesStringGrid.Canvas
  do begin
       if gdFixed in State
       then begin
              if (ARow <> 0) and (ACol = 0)
              then begin
                     FillRect(Rect);
                     str := IntToStr(ARow);
                     if ARow < LCDScreenNbOfLines + 1
                     then Font.Color := PixOnColor
                     else Font.Color := clSilver;
                     end
              else if (ACol <> 0) and (ARow = 0)
                   then begin
                          str := IntToStr(ACol);
                          if ACol < LCDScreenNbOfChars + 1
                          then Font.Color := PixOnColor
                          else Font.Color := clSilver;
                          end;

              TextOut(Rect.Left + (LinesStringGrid.DefaultColWidth - TextWidth(str)) div 2, Rect.Top + 2, str);
              end

       else begin
              FlagInverse := False;
              str := LinesStringGrid.Cells[0, ARow];

              if CountSpecialCharString(str) <> 0
              then begin
                     i := 0;
                     offset := 0;
                     repeat
                       if CountSpecialCharString(str[i + offset]) <> 0
                       then Inc(offset)
                       else Inc(i);
                       until i > ACol;

                     if offset <> 0
                     then begin
                            inverse_charpos := i + offset - 1;
                            repeat
                              str := Copy(LinesStringGrid.Cells[0, ARow], inverse_charpos, 1);
                              Dec(inverse_charpos);
                              until (str = startinverse_char) or (str = stopinverse_char) or (inverse_charpos = 0);
                            if str = startinverse_char then FlagInverse := True;

                            blinking_charpos := i + offset - 1;
                            repeat
                              str := Copy(LinesStringGrid.Cells[0, ARow], blinking_charpos, 1);
                              Dec(blinking_charpos);
                              until (str = startblinking_char) or (str = stopblinking_char) or (blinking_charpos = 0);
                            if str = startblinking_char then FlagInverse := FBlinking;
                            end;
                     end;

              if (ACol > LCDScreenNbOfChars) or (ARow > LCDScreenNbOfLines)
              then begin
                     if ARow = LinesStringGrid.Selection.Top
                     then Brush.Color := clHighlight
                     else Brush.Color := clWhite;
                     Pen.Style := psInsideFrame;
                     Rectangle(Rect);
                     end
              else begin
                     if ARow = LinesStringGrid.Selection.Top
                     then Brush.Color := clHighlight;
                     FillRect(Rect);
                     end;

              if FlagInverse
              then begin
                     Brush.Color := LinesStringGrid.Font.Color;
                     Font.Color := LinesStringGrid.Color;
                     FillRect(Rect);
                     end;

              str := LinesStringGrid.Cells[ACol, ARow];

              TextOut(Rect.Left + (LinesStringGrid.DefaultColWidth - TextWidth(str)) div 2, Rect.Top + 2, str);
              end;
       end;
end;


procedure TLCDScreenLinesEditorForm.InsertButtonClick(Sender: TObject);
var i: Integer;
begin
  with LinesStringGrid do
  begin
    RowCount := RowCount + 1;

    for i := RowCount downto Selection.Top + 1
    do Rows[i] := Rows[i - 1];

    Rows[Selection.Top].Clear;
    end;
end;


procedure TLCDScreenLinesEditorForm.AddButtonClick(Sender: TObject);
var i: Integer;
begin
  with LinesStringGrid do
  begin
    RowCount := RowCount + 1;

    for i := RowCount downto Selection.Top + 1
    do Rows[i] := Rows[i - 1];
    Rows[Selection.Top + 1].Clear;

    end;
end;


procedure TLCDScreenLinesEditorForm.DeleteButtonClick(Sender: TObject);
var i:Integer;
begin
  with LinesStringGrid do
  begin
    for i := Selection.Top to RowCount - 1
    do Rows[i] := Rows[i + 1];

    Rows[RowCount].Clear;
    RowCount := Max(LCDScreenNbOfLines, NbOfRealLines(LinesStringGrid)) + 2;
    end;
end;


procedure TLCDScreenLinesEditorForm.EditButtonClick(Sender: TObject);
begin
  Timer.Enabled := False;
  OKButton.Enabled := False;
  CancelButton.Enabled := False;


  with LinesStringGrid
  do begin
       LineEdit.Top := 1 + Top + (Selection.Top - TopRow + 1) * (DefaultRowHeight + 1);

       if TopRow > Selection.Top
       then begin
              TopRow := Selection.Top;
              LineEdit.Top := Top + DefaultRowHeight + 2;
              end;

       LineEdit.Text := Cells[0, Selection.Top];
       LineEdit.Show;
       EditLinePanel.Show;
       LineEdit.SetFocus;
       ScrollBars := ssHorizontal;
       PopupMenu := nil;
       end;
  LineEdit.AutoSelect := False;
end;


procedure TLCDScreenLinesEditorForm.LineEditExit(Sender: TObject);
begin
  if ActiveControl.Name = 'CancelEditButton' then CancelEditButtonClick(Sender)
  else if ActiveControl.Name = 'LinesStringGrid' then OKEditButtonClick(Sender);
end;


procedure TLCDScreenLinesEditorForm.CancelEditButtonClick(Sender: TObject);
begin
  LineEdit.Hide;
  EditLinePanel.Hide;
  LinesStringGrid.ScrollBars := ssBoth;
  LinesStringGrid.PopupMenu := LinesCellPUM;
  OKButton.Enabled := True;
  CancelButton.Enabled := True;
  LineEdit.AutoSelect := True;
  if BlinkingMenu.Checked then Timer.Enabled := True;
end;


procedure TLCDScreenLinesEditorForm.OKEditButtonClick(Sender: TObject);
var i,offset,
    startinverse_charpos, stopinverse_charpos,
    startblinking_charpos, stopblinking_charpos,
    startunderline_charpos, stopunderline_charpos,
    startstrike_charpos, stopstrike_charpos: Byte;
    tempstr: String;


  function CountNbOfChar(c: Char; s:String):Byte;
  var i: Byte;
  begin
     i := 0;
     while Pos(c, s) > 0 do begin
                              s[Pos(c, s)] := '0';
                              Inc(i);
                              end;
     CountNbOfChar := i;
  end;


begin
  tempstr := LineEdit.Text;

  startinverse_charpos   := CountNbOfChar(startinverse_char, tempstr);
  stopinverse_charpos    := CountNbOfChar(stopinverse_char, tempstr);
  startblinking_charpos  := CountNbOfChar(startblinking_char, tempstr);
  stopblinking_charpos   := CountNbOfChar(stopblinking_char, tempstr);
  startunderline_charpos := CountNbOfChar(startunderline_char, tempstr);
  stopunderline_charpos  := CountNbOfChar(stopunderline_char, tempstr);
  startstrike_charpos    := CountNbOfChar(startstrike_char, tempstr);
  stopstrike_charpos     := CountNbOfChar(stopstrike_char, tempstr);

  if startinverse_charpos <> stopinverse_charpos
  then begin
         MessageDlg('Synthax error with start/stop inverse characters.' +
                    #13 + #13 + 'Number of startinverse_char: ' + InttoStr(startinverse_charpos) +
                    #13 +  'Number of stopinverse_char: ' + InttoStr(stopinverse_charpos),
                    mtError, [mbOK], 0);
         Exit;
         end;

  if startblinking_charpos <> stopblinking_charpos
  then begin
         MessageDlg('Synthax error with start/stop blinking characters.' +
                    #13 + #13 + 'Number of startblinking_char: ' + InttoStr(startblinking_charpos) +
                    #13 +  'Number of stopblinking_char: ' + InttoStr(stopblinking_charpos),
                    mtError, [mbOK], 0);
         Exit;
         end;

  if startunderline_charpos <> stopunderline_charpos
  then begin
         MessageDlg('Synthax error with start/stop underline characters.' +
                    #13 + #13 + 'Number of startunderline_char: ' + InttoStr(startunderline_charpos) +
                    #13 +  'Number of stopunderline_char: ' + InttoStr(stopunderline_charpos),
                    mtError, [mbOK], 0);
         Exit;
         end;

  if startstrike_charpos <> stopstrike_charpos
  then begin
         MessageDlg('Synthax error with start/stop strike characters.' +
                    #13 + #13 + 'Number of startstrike_char: ' + InttoStr(startstrike_charpos) +
                    #13 +  'Number of stopstrike_char: ' + InttoStr(stopstrike_charpos),
                    mtError, [mbOK], 0);
         Exit;
         end;


  with LinesStringGrid
  do begin
        Cells[0, Selection.Top] := LineEdit.Text;
        offset := 0;

        for i := 1 to Rowcount - 1
        do offset := Max(Length(Cells[0, i]) - CountSpecialCharString(Cells[0, i]), offset);
        ColCount := offset + 2;

        if Length(tempstr) <> 0
        then begin
               i := 0;
               offset := 0;
               repeat
                 if CountSpecialCharString(tempstr[i + 1]) = 0
                 then Cells[i + 1 - offset, Selection.Top] := tempstr[i + 1]
                 else Inc(offset);
                 Inc(i);
                 until i >= Length(tempstr);
               end;
               for i := i + 1 to ColCount
               do Cells[i, Selection.Top] := '';
               end;

  CancelEditButtonClick(Sender);
end;


procedure TLCDScreenLinesEditorForm.BlinkingButtonClick(Sender: TObject);
var tempstr: String;
begin
  with LineEdit
  do begin
       tempstr := Text;
       Insert(startblinking_char, tempstr, SelStart + 1);
       Insert(stopblinking_char, tempstr, SelStart + SelLength + 2);
       Text := tempstr;
       end;
  LineEdit.SetFocus;
end;


procedure TLCDScreenLinesEditorForm.InverseButtonClick(Sender: TObject);
var tempstr: String;
begin
  with LineEdit
  do begin
       tempstr := Text;
       Insert(startinverse_char, tempstr, SelStart + 1);
       Insert(stopinverse_char, tempstr, SelStart + SelLength + 2);
       Text := tempstr;
       end;
  LineEdit.SetFocus;
end;


procedure TLCDScreenLinesEditorForm.UnderlineButtonClick(Sender: TObject);
var tempstr: String;
begin
  with LineEdit
  do begin
       tempstr := Text;
       Insert(startunderline_char, tempstr, SelStart + 1);
       Insert(stopunderline_char, tempstr, SelStart + SelLength + 2);
       Text := tempstr;
       end;
  LineEdit.SetFocus;
end;


procedure TLCDScreenLinesEditorForm.StrikeButtonClick(Sender: TObject);
var tempstr: String;
begin
  with LineEdit
  do begin
       tempstr := Text;
       Insert(startstrike_char, tempstr, SelStart + 1);
       Insert(stopstrike_char, tempstr, SelStart + SelLength + 2);
       Text := tempstr;
       end;
  LineEdit.SetFocus;
end;


procedure TLCDScreenLinesEditorForm.ClearButtonClick(Sender: TObject);
begin
  with LinesStringGrid do
    Rows[Selection.Top].Clear;
end;


procedure TLCDScreenLinesEditorForm.RemoveSpButtonClick(Sender: TObject);
var tempstr: String;
begin
  with LineEdit
  do begin
       tempstr := Text;
       repeat
         Delete(tempstr, Pos(startinverse_char, tempstr),1);
         Delete(tempstr, Pos(stopinverse_char, tempstr),1);
         Delete(tempstr, Pos(startblinking_char, tempstr),1);
         Delete(tempstr, Pos(stopblinking_char, tempstr),1);
         Delete(tempstr, Pos(startunderline_char, tempstr),1);
         Delete(tempstr, Pos(stopunderline_char, tempstr),1);
         Delete(tempstr, Pos(startstrike_char, tempstr),1);
         Delete(tempstr, Pos(stopstrike_char, tempstr),1);
       until CountSpecialCharString(tempstr) = 0;
       Text := tempstr;
       end;
  LineEdit.SetFocus;
end;


procedure TLCDScreenLinesEditorForm.LinesStringGridKeyDown(Sender: TObject;
  var Key: Word; Shift: TShiftState);
begin
  if Key = vk_F2 then EditButtonClick(Sender);
end;
procedure TLCDScreenLinesEditorForm.LineEditMouseUp(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  LineEditMouseMove(Sender, Shift, X, Y);
end;


procedure TLCDScreenLinesEditorForm.LinesStringGridClick(Sender: TObject);
begin
  if LineEdit.Visible then CancelEditButtonClick(Sender);
end;
procedure TLCDScreenLinesEditorForm.LineEditMouseMove(Sender: TObject;
  Shift: TShiftState; X, Y: Integer);
begin
  if (LineEdit.SelLength <> 0)
  then begin
         BlinkingButton.Enabled := True;
         InverseButton.Enabled := True;
         UnderlineButton.Enabled := True;
         StrikeButton.Enabled := True;
         end
  else begin
         BlinkingButton.Enabled := False;
         InverseButton.Enabled := False;
         UnderlineButton.Enabled := False;
         StrikeButton.Enabled := False;
         end
end;


procedure TLCDScreenLinesEditorForm.LinesStringGridMouseUp(Sender: TObject;
  Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var ACol, ARow: Integer;
begin
  with LinesStringGrid
  do MouseToCell(Mouse.CursorPos.X - ClientOrigin.X,
                 Mouse.CursorPos.Y - ClientOrigin.Y, ACol, ARow);
  if (ACol = 0) and (ARow = 0) then BlinkingMenuClick(Sender);
end;


procedure TLCDScreenLinesEditorForm.BlinkingMenuClick(
  Sender: TObject);
begin
  BlinkingMenu.Checked := not BlinkingMenu.Checked;
  if BlinkingMenu.Checked
  then begin
         Timer.Enabled := True;
         LinesStringGrid.Cells[0,0] := '*';
         end
  else begin
         Timer.Enabled := False;
         LinesStringGrid.Cells[0,0] := '