mirror of
https://gitlab.com/freepascal.org/lazarus/lazarus.git
synced 2025-06-20 03:28:21 +02:00
10521 lines
315 KiB
ObjectPascal
10521 lines
315 KiB
ObjectPascal
{
|
|
*****************************************************************************
|
|
* gtk3widgets.pas *
|
|
* ------------- *
|
|
* *
|
|
* *
|
|
*****************************************************************************
|
|
|
|
*****************************************************************************
|
|
This file is part of the Lazarus Component Library (LCL)
|
|
|
|
See the file COPYING.modifiedLGPL.txt, included in this distribution,
|
|
for details about the license.
|
|
*****************************************************************************
|
|
}
|
|
|
|
unit Gtk3Widgets;
|
|
|
|
{$mode objfpc}{$H+}
|
|
{$i gtk3defines.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
Classes, SysUtils, types, math,
|
|
// LCL
|
|
Controls, StdCtrls, ExtCtrls, Buttons, ComCtrls, Graphics, Dialogs, Forms, Menus, ExtDlgs,
|
|
Spin, CheckLst, PairSplitter, LCLType, LMessages, LCLMessageGlue, LCLIntf,
|
|
// LazUtils
|
|
GraphType,
|
|
// GTK3
|
|
LazGtk3, LazGdk3, LazGObject2, LazGLib2, LazCairo1, LazPango1, LazGdkPixbuf2,
|
|
gtk3objects, gtk3procs, gtk3private, Gtk3CellRenderer;
|
|
|
|
type
|
|
TByteSet = set of byte;
|
|
|
|
// records
|
|
TPaintData = record
|
|
PaintWidget: PGtkWidget;
|
|
ClipRect: PRect;
|
|
ClipRegion: Pcairo_region_t;
|
|
end;
|
|
|
|
TDefaultRGBA = record
|
|
R: Double;
|
|
G: Double;
|
|
B: Double;
|
|
Alpha: Double;
|
|
end;
|
|
|
|
TGtk3WidgetType = (wtWidget, wtStaticText, wtProgressBar, wtLayout,
|
|
wtContainer, wtMenuBar, wtMenu, wtMenuItem, wtEntry, wtSpinEdit,
|
|
wtNotebook, wtTabControl, wtComboBox, wtPanel,
|
|
wtGroupBox, wtCalendar, wtTrackBar, wtScrollBar,
|
|
wtScrollingWin, wtListBox, wtListView, wtCheckListBox, wtMemo, wtTreeModel,
|
|
wtCustomControl, wtScrollingWinControl,
|
|
wtWindow, wtDialog, wtHintWindow, wtGLArea);
|
|
TGtk3WidgetTypes = set of TGtk3WidgetType;
|
|
|
|
TGtk3GroupBoxType = (gbtGroupBox, gbtCheckGroup, gbtRadioGroup);
|
|
|
|
{ TGtk3Widget }
|
|
|
|
TGtk3Widget = class(TGtk3Object, IUnknown)
|
|
private
|
|
FCairoContext: Pcairo_t;
|
|
FShape: PGdkPixbuf;
|
|
FContext: HDC;
|
|
FPaintData: TPaintData;
|
|
FDrawSignal: GULong; // needed by designer
|
|
FFont: PPangoFontDescription;
|
|
class function WidgetEvent(widget: PGtkWidget; event: PGdkEvent; data: GPointer): gboolean; cdecl; static; {main event filter of widget}
|
|
strict private
|
|
FCentralWidgetRGBA: array [0{GTK_STATE_NORMAL}..4{GTK_STATE_INSENSITIVE}] of TDefaultRGBA;
|
|
FEnterLeaveTime: Cardinal;
|
|
FFocusableByMouse: Boolean; {shell we call SetFocus on mouse down. Default = False}
|
|
FHasCaret: boolean;
|
|
FOwner: PGtkWidget;
|
|
FProps: TStringList;
|
|
FWidgetMapped: boolean;
|
|
FWidgetRGBA: array [0{GTK_STATE_NORMAL}..4{GTK_STATE_INSENSITIVE}] of TDefaultRGBA;
|
|
function CanSendLCLMessage: Boolean;
|
|
function GetCairoContext: Pcairo_t;
|
|
function GetEnabled: Boolean;
|
|
function GetFont: PPangoFontDescription;
|
|
function GetStyleContext: PGtkStyleContext;
|
|
function GetVisible: Boolean;
|
|
procedure SetEnabled(AValue: Boolean);
|
|
procedure SetFont(AValue: PPangoFontDescription);
|
|
procedure SetShape(AValue: PGdkPixbuf);
|
|
procedure SetStyleContext({%H-}AValue: PGtkStyleContext);
|
|
class procedure DestroyWidgetEvent({%H-}w: PGtkWidget;{%H-}data:gpointer); cdecl; static;
|
|
class function DrawWidget(AWidget: PGtkWidget; AContext: Pcairo_t; Data: gpointer): gboolean; cdecl; static;
|
|
class procedure MapWidget(AWidget: PGtkWidget; Data: gPointer); cdecl; static; {GtkWindow never sends this signal !}
|
|
class function MouseEnterNotify(aWidget: PGtkWidget; aEvent: PGdkEventCrossing; aData: gpointer): gboolean; cdecl; static;
|
|
class function MouseLeaveNotify(aWidget: PGtkWidget; aEvent: PGdkEventCrossing; aData: gpointer): gboolean; cdecl; static;
|
|
class function ScrollEvent(AWidget: PGtkWidget; AEvent: PGdkEvent; AData: GPointer): GBoolean; cdecl; static;
|
|
class procedure SizeAllocate(AWidget: PGtkWidget; AGdkRect: PGdkRectangle; Data: gpointer); cdecl; static;
|
|
class procedure WidgetHide({%H-}AWidget:PGtkWidget; AData:gpointer); cdecl; static;
|
|
class procedure WidgetShow({%H-}AWidget:PGtkWidget; AData:gpointer); cdecl; static;
|
|
|
|
class procedure DragDataReceived(aWidget: PGtkWidget;
|
|
aContext: PGdkDragContext; x: gint; y: gint;
|
|
selection_data: PGtkSelectionData; info: guint; time: guint;
|
|
aData: gPointer); cdecl; static;
|
|
|
|
protected
|
|
FCentralWidget: PGtkWidget;
|
|
FHasPaint: Boolean;
|
|
FKeysToEat: TByteSet;
|
|
FParams: TCreateParams;
|
|
fText: string;
|
|
FOwnWidget: Boolean;
|
|
FWidget: PGtkWidget;
|
|
FWidgetType: TGtk3WidgetTypes;
|
|
// IUnknown implementation
|
|
function QueryInterface(constref iid: TGuid; out obj): LongInt; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
|
|
function _AddRef: LongInt; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
|
|
function _Release: LongInt; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
|
|
function IsDesigning: boolean; virtual;
|
|
function EatArrowKeys(const AKey: Word): Boolean; virtual;
|
|
function getText: String; virtual;
|
|
procedure setText(const AValue: String); virtual;
|
|
function GetContext: HDC; virtual;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; virtual;
|
|
procedure DestroyWidget; virtual;
|
|
procedure DoBeforeLCLPaint; virtual;
|
|
|
|
function GetColor: TColor; virtual;
|
|
procedure SetColor(AValue: TColor); virtual;
|
|
function GetFontColor: TColor; virtual;
|
|
procedure SetFontColor(AValue: TColor); virtual;
|
|
function GetWidget:PGtkWidget;
|
|
procedure ConnectSizeAllocateSignal(ToWidget: PGtkWidget); virtual;
|
|
procedure SetVisible(AValue: Boolean); virtual;
|
|
public
|
|
LCLObject: TWinControl;
|
|
LCLWidth: integer; {setted up only TWSControl.SetBounds}
|
|
LCLHeight: integer; {setted up only TWSControl.SetBounds}
|
|
public
|
|
constructor Create(const AWinControl: TWinControl; const AParams: TCreateParams); virtual; overload;
|
|
constructor CreateFrom(const AWinControl: TWinControl; AWidget: PGtkWidget); virtual;
|
|
|
|
procedure InitializeWidget; virtual;
|
|
|
|
procedure DeInitializeWidget;
|
|
procedure RecreateWidget;
|
|
procedure DestroyNotify({%H-}AWidget: PGtkWidget); virtual;
|
|
destructor Destroy; override;
|
|
|
|
function CanFocus: Boolean; virtual;
|
|
function GetFocusableByMouse: Boolean;
|
|
function getClientOffset: TPoint; virtual;
|
|
function getWidgetPos: TPoint; virtual;
|
|
|
|
procedure OffsetMousePos(APoint: PPoint); virtual;
|
|
|
|
function ClientToScreen(var P:TPoint):boolean;
|
|
function ScreenToClient(var P: TPoint): Integer;
|
|
|
|
function DeliverMessage(var Msg; const AIsInputEvent: Boolean = False): LRESULT; virtual;
|
|
function GtkEventKey(Sender: PGtkWidget; Event: PGdkEvent; AKeyPress: Boolean): Boolean; virtual; cdecl;
|
|
function GtkEventMouse(Sender: PGtkWidget; Event: PGdkEvent): Boolean; virtual; cdecl;
|
|
function GtkEventMouseMove(Sender: PGtkWidget; Event: PGdkEvent): Boolean; virtual; cdecl;
|
|
function GtkEventPaint(Sender: PGtkWidget; AContext: Pcairo_t): Boolean; virtual; cdecl;
|
|
function GtkEventResize(Sender: PGtkWidget; Event: PGdkEvent): Boolean; virtual; cdecl;
|
|
procedure GtkEventFocus(Sender: PGtkWidget; Event: PGdkEvent); cdecl;
|
|
procedure GtkEventDestroy; cdecl;
|
|
|
|
function IsValidHandle: Boolean;
|
|
function IsWidgetOk: Boolean; virtual;
|
|
function IsIconic: Boolean; virtual;
|
|
|
|
function getType: TGType;
|
|
function getTypeName: PgChar;
|
|
|
|
procedure lowerWidget; virtual;
|
|
procedure raiseWidget; virtual;
|
|
procedure stackUnder(AWidget: PGtkWidget); virtual;
|
|
|
|
function GetCapture: TGtk3Widget; virtual;
|
|
function SetCapture: HWND; virtual;
|
|
|
|
function getClientRect: TRect; virtual;
|
|
function getClientBounds: TRect; virtual;
|
|
|
|
procedure SetBounds(ALeft,ATop,AWidth,AHeight:integer); virtual;
|
|
procedure SetLclFont(const AFont:TFont); virtual;
|
|
procedure SetWindowShape(AShape: PGdkPixBuf; AWindow: PGdkWindow); virtual;
|
|
|
|
function GetContainerWidget: PGtkWidget; virtual;
|
|
function GetPosition(out APoint: TPoint): Boolean; virtual;
|
|
procedure Release; override;
|
|
procedure Hide; virtual;
|
|
function getParent: TGtk3Widget;
|
|
function GetWindow: PGdkWindow; virtual;
|
|
procedure Move(ALeft, ATop: Integer);
|
|
procedure Activate; virtual;
|
|
procedure preferredSize(var PreferredWidth, PreferredHeight: integer; {%H-}WithThemeSpace: Boolean); virtual;
|
|
procedure SetCursor(ACursor: HCURSOR);
|
|
procedure SetFocus; virtual;
|
|
procedure SetParent(AParent: TGtk3Widget; const ALeft, ATop: Integer); virtual;
|
|
procedure Show; virtual;
|
|
procedure ShowAll; virtual;
|
|
procedure Update(ARect: PRect); virtual;
|
|
property CairoContext: Pcairo_t read GetCairoContext;
|
|
property Color: TColor read GetColor write SetColor;
|
|
property Context: HDC read GetContext;
|
|
property Enabled: Boolean read GetEnabled write SetEnabled;
|
|
property Font: PPangoFontDescription read GetFont write SetFont;
|
|
property FontColor: TColor read GetFontColor write SetFontColor;
|
|
property HasCaret: boolean read FHasCaret write FHasCaret;
|
|
property KeysToEat: TByteSet read FKeysToEat write FKeysToEat;
|
|
property PaintData: TPaintData read FPaintData write FPaintData;
|
|
property Shape: PGdkPixbuf read FShape write SetShape;
|
|
property StyleContext: PGtkStyleContext read GetStyleContext write SetStyleContext;
|
|
property Text: String read getText write setText;
|
|
property Visible: Boolean read GetVisible write SetVisible;
|
|
property Widget: PGtkWidget read GetWidget;
|
|
property WidgetMapped: boolean read FWidgetMapped write FWidgetMapped; {very important. Gtk3 does not give us reliable informations about this state get_mapped returns true, but actually map event isn't arrived yet.}
|
|
property WidgetType: TGtk3WidgetTypes read FWidgetType;
|
|
end;
|
|
|
|
{ TGtk3Editable }
|
|
|
|
TGtk3Editable = class(TGtk3Widget)
|
|
private
|
|
function GetReadOnly: Boolean;
|
|
procedure SetReadOnly(AValue: Boolean);
|
|
protected
|
|
PrivateCursorPos: Integer; // used only for delayed selStart and selLength
|
|
PrivateSelection: Integer;
|
|
function getCaretPos: TPoint; virtual;
|
|
procedure SetCaretPos(AValue: TPoint); virtual;
|
|
public
|
|
function getSelStart: Integer; virtual;
|
|
function getSelLength: Integer; virtual;
|
|
procedure setSelStart(AValue: Integer); virtual;
|
|
procedure setSelLength(AValue: Integer); virtual;
|
|
property CaretPos: TPoint read GetCaretPos write SetCaretPos;
|
|
property ReadOnly: Boolean read GetReadOnly write SetReadOnly;
|
|
end;
|
|
|
|
{ TGtk3Entry }
|
|
|
|
TGtk3Entry = class(TGtk3Editable)
|
|
private
|
|
function GetAlignment: TAlignment;
|
|
procedure SetAlignment(AValue: TAlignment);
|
|
strict private
|
|
class procedure EntryChanged({%H-}AEntry: PGtkEntryBuffer; AData: GPointer); cdecl; static;
|
|
class procedure InsertText(editable: PGtkEditable; aNewText: PgChar; anewtextlen: gint;
|
|
var pos:Pgint; data: gpointer);cdecl; static;
|
|
class procedure EntrySizeAllocate(AWidget: PGtkWidget; AGdkRect: PGdkRectangle; Data: gpointer); cdecl; static;
|
|
protected
|
|
procedure ConnectSizeAllocateSignal(ToWidget: PGtkWidget); override;
|
|
function EatArrowKeys(const AKey: Word): Boolean; override;
|
|
function getText: String; override;
|
|
procedure setText(const AValue: String); override;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure preferredSize(var PreferredWidth, PreferredHeight: integer; {%H-}WithThemeSpace: Boolean); override;
|
|
procedure InitializeWidget; override;
|
|
procedure SetEchoMode(AVisible: Boolean);
|
|
procedure SetMaxLength(AMaxLength: Integer);
|
|
procedure SetPasswordChar(APasswordChar: Char);
|
|
procedure SetNumbersOnly(ANumbersOnly:boolean);
|
|
procedure SetTextHint(const AHint:string);
|
|
procedure SetFrame(const aborder:boolean);
|
|
procedure SetSelText(const ASelText: string);
|
|
function GetTextHint:string;
|
|
function IsWidgetOk: Boolean; override;
|
|
property Alignment: TAlignment read GetAlignment write SetAlignment;
|
|
property TextHint:string read GetTextHint write SetTextHint;
|
|
end;
|
|
|
|
{ TGtk3SpinEdit }
|
|
|
|
TGtk3SpinEdit = class(TGtk3Entry)
|
|
strict private
|
|
class procedure SpinValueChanged({%H-}aSpin: PGtkSpinButton; aData: gpointer); cdecl; static;
|
|
private
|
|
function GetMaximum: Double;
|
|
function GetMinimum: Double;
|
|
function GetNumDigits: Integer;
|
|
function GetNumeric: Boolean;
|
|
function GetStep: Double;
|
|
function GetValue: Double;
|
|
procedure SetNumDigits(AValue: Integer);
|
|
procedure SetNumeric(AValue: Boolean);
|
|
procedure SetStep(AValue: Double);
|
|
procedure SetValue(AValue: Double);
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
function EatArrowKeys(const {%H-}AKey: Word): Boolean; override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
function IsWidgetOk: Boolean; override;
|
|
procedure SetRange(AMin, AMax: Double);
|
|
property Minimum: Double read GetMinimum;
|
|
property Maximum: Double read GetMaximum;
|
|
property Numeric: Boolean read GetNumeric write SetNumeric;
|
|
property NumDigits: Integer read GetNumDigits write SetNumDigits;
|
|
property Step: Double read GetStep write SetStep;
|
|
property Value: Double read GetValue write SetValue;
|
|
end;
|
|
|
|
{ TGtk3Range }
|
|
|
|
TGtk3Range = class(TGtk3Widget)
|
|
strict private
|
|
class procedure RangeChanged(ARange:PGtkRange;AData:gPointer); cdecl; static;
|
|
private
|
|
function GetPosition: Integer; reintroduce;
|
|
function GetRange: TPoint;
|
|
procedure SetPosition(AValue: Integer);
|
|
procedure SetRange(AValue: TPoint);
|
|
public
|
|
procedure InitializeWidget; override;
|
|
procedure SetStep(AStep: Integer; APageSize: Integer);
|
|
property Range: TPoint read GetRange write SetRange;
|
|
property Position: Integer read GetPosition write SetPosition;
|
|
end;
|
|
|
|
{ TGtk3TrackBar }
|
|
|
|
TGtk3TrackBar = class(TGtk3Range)
|
|
private
|
|
FOrientation: TTrackBarOrientation;
|
|
function GetReversed: Boolean;
|
|
procedure SetReversed(AValue: Boolean);
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure SetBounds(ALeft,ATop,AWidth,AHeight:integer); override;
|
|
function GetTrackBarOrientation: TTrackBarOrientation;
|
|
procedure SetScalePos(AValue: TTrackBarScalePos);
|
|
procedure SetTickMarks(AValue: TTickMark; ATickStyle: TTickStyle);
|
|
property Reversed: Boolean read GetReversed write SetReversed;
|
|
end;
|
|
|
|
{ TGtk3ScrollBar }
|
|
|
|
TGtk3ScrollBar = class(TGtk3Range)
|
|
protected
|
|
class procedure ScrollBarValueChanged(adjustment: PGtkAdjustment; data:gpointer);cdecl; static;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure SetParams;
|
|
end;
|
|
|
|
{ TGtk3ProgressBar }
|
|
|
|
TGtk3ProgressBar = class(TGtk3Widget)
|
|
private
|
|
function GetOrientation: TProgressBarOrientation;
|
|
function GetPosition: Integer; reintroduce;
|
|
function GetShowText: Boolean;
|
|
function GetStyle: TProgressBarStyle;
|
|
procedure SetOrientation(AValue: TProgressBarOrientation);
|
|
procedure SetPosition(AValue: Integer);
|
|
procedure SetShowText(AValue: Boolean);
|
|
procedure SetStyle(AValue: TProgressBarStyle);
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
property Orientation: TProgressBarOrientation read GetOrientation write SetOrientation;
|
|
property Position: Integer read GetPosition write SetPosition;
|
|
property ShowText: Boolean read GetShowText write SetShowText;
|
|
property Style: TProgressBarStyle read GetStyle write SetStyle;
|
|
end;
|
|
|
|
{ TGtk3Calendar }
|
|
|
|
TGtk3Calendar = class(TGtk3Widget)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure GetDate(out AYear, AMonth, ADay: LongWord);
|
|
procedure SetDate(const AYear, AMonth, ADay: LongWord);
|
|
procedure SetDisplayOptions(const ADisplayOptions: TGtkCalendarDisplayOptions);
|
|
end;
|
|
|
|
{ TGtk3StaticText }
|
|
|
|
TGtk3StaticText = class(TGtk3Widget)
|
|
private
|
|
function GetAlignment: TAlignment;
|
|
function GetStaticBorderStyle: TStaticBorderStyle;
|
|
procedure SetAlignment(AValue: TAlignment);
|
|
procedure SetStaticBorderStyle(AValue: TStaticBorderStyle);
|
|
protected
|
|
function getText: String; override;
|
|
procedure setText(const AValue: String); override;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
property Alignment: TAlignment read GetAlignment write SetAlignment;
|
|
property StaticBorderStyle: TStaticBorderStyle read GetStaticBorderStyle write SetStaticBorderStyle;
|
|
end;
|
|
|
|
{ TGtk3Container }
|
|
|
|
TGtk3Container = class(TGtk3Widget)
|
|
protected
|
|
procedure SetVisible(AValue: Boolean); override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
end;
|
|
|
|
{ TGtk3Page }
|
|
|
|
TGtk3Page = class(TGtk3Container)
|
|
private
|
|
FPageLabel: PGtkLabel;
|
|
protected
|
|
procedure DoBeforeLCLPaint; override;
|
|
procedure setText(const AValue: String); override;
|
|
function CreateWidget(const Params: TCreateParams):PGtkWidget; override;
|
|
procedure DestroyWidget; override;
|
|
public
|
|
function getClientOffset:TPoint; override;
|
|
function getClientRect: TRect; override;
|
|
end;
|
|
|
|
{ TGtk3NoteBook }
|
|
|
|
TGtk3NoteBook = class (TGtk3Container)
|
|
private
|
|
FDefaultClientRect:TRect;
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
function GetTabSize(AWinControl: TWinControl): integer; {returns size of tab. Height if orientation is top/bottom, width if orientation is left/right}
|
|
function getClientRect: TRect; override;
|
|
function getPagesCount: integer;
|
|
procedure InsertPage(ACustomPage: TCustomPage; AIndex: Integer);
|
|
procedure MovePage(ACustomPage: TCustomPage; ANewIndex: Integer);
|
|
procedure RemovePage(AIndex: Integer);
|
|
procedure SetPageIndex(AIndex: Integer);
|
|
procedure SetShowTabs(const AShowTabs: Boolean);
|
|
procedure SetTabPosition(const ATabPosition: TTabPosition);
|
|
procedure SetTabLabelText(AChild: TCustomPage; const AText: String);
|
|
function GetTabLabelText(AChild: TCustomPage): String;
|
|
property DefaultClientRect: TRect read FDefaultClientRect write FDefaultClientRect; //measured in gtk3wscomctrls.getDefaultClientRect
|
|
end;
|
|
|
|
{ TGtk3Bin }
|
|
|
|
TGtk3Bin = class(TGtk3Container)
|
|
end;
|
|
|
|
|
|
{ TGtk3Paned }
|
|
|
|
TGtk3Paned = class(TGtk3Container)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
end;
|
|
|
|
{ TGtk3SplitterSide }
|
|
|
|
TGtk3SplitterSide = class(TGtk3Container)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
end;
|
|
|
|
|
|
{ TGtk3MenuShell }
|
|
|
|
TGtk3MenuShell = class(TGtk3Container)
|
|
public
|
|
MenuObject: TMenu;
|
|
constructor Create(const AMenu: TMenu; AMenuBar: PGtkMenuBar); virtual; overload;
|
|
procedure Insert(AMenuShell: PGtkMenuShell; APosition: Integer);
|
|
procedure InitializeWidget; override;
|
|
end;
|
|
|
|
{ TGtk3MenuBar }
|
|
|
|
TGtk3MenuBar = class(TGtk3MenuShell)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
end;
|
|
|
|
{ TGtk3Menu }
|
|
|
|
TGtk3Menu = class(TGtk3MenuShell)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
PopupPoint: TPoint;
|
|
constructor CreateFromMenuItem(const AMenuItem: TMenuItem); virtual; overload;
|
|
end;
|
|
|
|
{ TGtk3MenuItem }
|
|
|
|
TGtk3MenuItem = class(TGtk3Bin)
|
|
private
|
|
function GetCaption: string;
|
|
procedure SetCaption(const AValue: string);
|
|
strict private
|
|
class procedure MenuItemActivated(AItem:PGtkMenuItem;AData:GPointer); cdecl; static;
|
|
class function MenuItemEvent(AWidget:PGtkWidget;event:PGdkEvent; data:GPointer):gboolean; cdecl; static;
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
Lock:integer;
|
|
MenuItem: TMenuItem;
|
|
constructor Create(const AMenuItem: TMenuItem); virtual; overload;
|
|
procedure InitializeWidget; override;
|
|
procedure SetCheck(ACheck:boolean);
|
|
property Caption: string read GetCaption write SetCaption;
|
|
end;
|
|
|
|
{ TGtk3ScrollableWin }
|
|
|
|
TGtk3ScrollableWin = class(TGtk3Container)
|
|
private
|
|
FBorderStyle: TBorderStyle;
|
|
FHBarInitialized, FVBarInitialized: boolean;
|
|
function GetHScrollBarPolicy: TGtkPolicyType;
|
|
function GetVScrollBarPolicy: TGtkPolicyType;
|
|
procedure SetBorderStyle(AValue: TBorderStyle);
|
|
procedure SetHScrollBarPolicy(AValue: TGtkPolicyType); virtual;
|
|
procedure SetVScrollBarPolicy(AValue: TGtkPolicyType); virtual;
|
|
protected
|
|
class procedure ScrolledLayoutSizeAllocate(AWidget: PGtkWidget;
|
|
AGdkRect: PGdkRectangle; Data: gpointer); cdecl; static; {very important, see note inside method}
|
|
|
|
class function RangeChangeValue(ARange: PGtkRange; AScrollType: TGtkScrollType;
|
|
AValue: gdouble; AData: gPointer): gboolean; cdecl; static;
|
|
class procedure RangeValueChanged(range: PGtkRange; data: gpointer); cdecl; static;
|
|
public
|
|
LCLVAdj: PGtkAdjustment; // used to keep LCL values
|
|
LCLHAdj: PGtkAdjustment; // used to keep LCL values
|
|
procedure DestroyWidget; override;
|
|
{result = true if scrollbar is pressed by mouse, AMouseOver if mouse is over scrollbar pressed or not.}
|
|
class function CheckIfScrollbarPressed(scrollbar: PGtkWidget; out AMouseOver:
|
|
boolean; const ACheckModifier: TGdkModifierTypeIdx): boolean;
|
|
procedure InitializeWidget; override;
|
|
procedure SetScrollBarsSignalHandlers(const AIsHorizontalScrollBar: boolean);
|
|
function getClientBounds: TRect; override;
|
|
function getViewport: PGtkViewport; virtual;
|
|
function getHorizontalScrollbar: PGtkScrollbar; virtual; abstract;
|
|
function getVerticalScrollbar: PGtkScrollbar; virtual; abstract;
|
|
function getScrolledWindow: PGtkScrolledWindow; virtual; abstract;
|
|
property BorderStyle: TBorderStyle read FBorderStyle write SetBorderStyle;
|
|
property HScrollBarPolicy: TGtkPolicyType read GetHScrollBarPolicy write SetHScrollBarPolicy;
|
|
property VScrollBarPolicy: TGtkPolicyType read GetVScrollBarPolicy write SetVScrollBarPolicy;
|
|
end;
|
|
|
|
{ TGtk3ToolBar }
|
|
|
|
TGtk3ToolBar = class(TGtk3Container)
|
|
private
|
|
fBmpList:TList;
|
|
procedure ButtonClicked(data: gPointer); cdecl;
|
|
procedure ClearGlyphs;
|
|
public
|
|
destructor Destroy; override;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
end;
|
|
|
|
{ TGtk3Memo }
|
|
|
|
TGtk3Memo = class(TGtk3ScrollableWin)
|
|
private
|
|
function GetAlignment: TAlignment;
|
|
function GetCaretPos: TPoint;
|
|
function GetReadOnly: Boolean;
|
|
function GetWantTabs: Boolean;
|
|
function GetWordWrap: Boolean;
|
|
procedure SetAlignment(AValue: TAlignment);
|
|
procedure SetCaretPos(AValue: TPoint);
|
|
procedure SetReadOnly(AValue: Boolean);
|
|
procedure SetWantTabs(AValue: Boolean);
|
|
procedure SetWordWrap(AValue: Boolean);
|
|
protected
|
|
function getText: String; override;
|
|
procedure setText(const AValue: String); override;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
function EatArrowKeys(const {%H-}AKey: Word): Boolean; override;
|
|
public
|
|
function getHorizontalScrollbar: PGtkScrollbar; override;
|
|
function getVerticalScrollbar: PGtkScrollbar; override;
|
|
function GetScrolledWindow: PGtkScrolledWindow; override;
|
|
public
|
|
function getSelStart: Integer; virtual;
|
|
function getSelLength: Integer; virtual;
|
|
procedure setSelStart(AValue: Integer); virtual;
|
|
procedure setSelLength(AValue: Integer); virtual;
|
|
procedure setSelText(const ANewSelText: string); virtual;
|
|
|
|
property Alignment: TAlignment read GetAlignment write SetAlignment;
|
|
property CaretPos: TPoint read GetCaretPos write SetCaretPos;
|
|
property ReadOnly: Boolean read GetReadOnly write SetReadOnly;
|
|
property WantTabs: Boolean read GetWantTabs write SetWantTabs;
|
|
property WordWrap: Boolean read GetWordWrap write SetWordWrap;
|
|
end;
|
|
|
|
{ TGtk3ListBox }
|
|
|
|
TGtk3ListBox = class(TGtk3ScrollableWin)
|
|
private
|
|
FListBoxStyle: TListBoxStyle;
|
|
function GetItemIndex: Integer;
|
|
function GetMultiSelect: Boolean;
|
|
procedure SetItemIndex(AValue: Integer);
|
|
procedure SetListBoxStyle(AValue: TListBoxStyle);
|
|
procedure SetMultiSelect(AValue: Boolean);
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
function EatArrowKeys(const {%H-}AKey: Word): Boolean; override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
function getHorizontalScrollbar: PGtkScrollbar; override;
|
|
function getVerticalScrollbar: PGtkScrollbar; override;
|
|
function GetScrolledWindow: PGtkScrolledWindow; override;
|
|
public
|
|
function GetSelCount: Integer;
|
|
function GetSelection: PGtkTreeSelection;
|
|
function GetItemRect(const AIndex: integer): TRect;
|
|
function GetIndexAtXY(const X, Y: integer): integer;
|
|
function GetItemSelected(const AIndex: Integer): Boolean;
|
|
function GetScrollWidth: integer;
|
|
procedure SelectItem(const AIndex: Integer; ASelected: Boolean);
|
|
procedure SetTopIndex(const AIndex: Integer);
|
|
property ItemIndex: Integer read GetItemIndex write SetItemIndex;
|
|
property MultiSelect: Boolean read GetMultiSelect write SetMultiSelect;
|
|
property ListBoxStyle: TListBoxStyle read FListBoxStyle write SetListBoxStyle;
|
|
end;
|
|
|
|
{ TGtk3CheckListBox }
|
|
|
|
TGtk3CheckListBox = class(TGtk3ListBox)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams): PGtkWidget; override;
|
|
end;
|
|
|
|
{ TGtk3ListView }
|
|
|
|
TGtk3ListView = class(TGtk3ScrollableWin)
|
|
private
|
|
FPreselectedIndices: TFPList;
|
|
FImages: TFPList;
|
|
FIsTreeView: Boolean;
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
function EatArrowKeys(const {%H-}AKey: Word): Boolean; override;
|
|
procedure SetColor(AValue: TColor); override;
|
|
class function selection_changed(AIconView: PGtkIconView; aData: gPointer):gboolean; cdecl; static;
|
|
public
|
|
destructor Destroy; override;
|
|
{interface implementation}
|
|
function getHorizontalScrollbar: PGtkScrollbar; override;
|
|
function getVerticalScrollbar: PGtkScrollbar; override;
|
|
function GetScrolledWindow: PGtkScrolledWindow; override;
|
|
procedure ClearImages;
|
|
procedure ColumnDelete(AIndex: Integer);
|
|
function ColumnGetWidth(AIndex: Integer): Integer;
|
|
procedure ColumnInsert(AIndex: Integer; AColumn: TListColumn);
|
|
procedure SetAlignment(AIndex: Integer; {%H-}AColumn: TListColumn; AAlignment: TAlignment);
|
|
procedure SetColumnAutoSize(AIndex: Integer; {%H-}AColumn: TListColumn; AAutoSize: Boolean);
|
|
procedure SetColumnCaption(AIndex: Integer; {%H-}AColumn: TListColumn; const ACaption: String);
|
|
procedure SetColumnMaxWidth(AIndex: Integer; {%H-}AColumn: TListColumn; AMaxWidth: Integer);
|
|
procedure SetColumnMinWidth(AIndex: Integer; {%H-}AColumn: TListColumn; AMinWidth: Integer);
|
|
procedure SetColumnWidth(AIndex: Integer; {%H-}AColumn: TListColumn; AWidth: Integer);
|
|
procedure SetColumnVisible(AIndex: Integer; {%H-}AColumn: TListColumn; AVisible: Boolean);
|
|
procedure ColumnSetSortIndicator(const AIndex: Integer; const {%H-}AColumn: TListColumn; const ASortIndicator: TSortIndicator);
|
|
|
|
procedure UpdateItem(AIndex:integer;AItem: TListItem);
|
|
procedure ItemDelete(AIndex: Integer);
|
|
function ItemDisplayRect(AIndex: Integer; ASubItem: integer; ACode: TDisplayCode): TRect;
|
|
procedure ItemInsert(AIndex: Integer; AItem: TListItem);
|
|
function ItemPosition(AIndex: integer): TPoint;
|
|
procedure ItemSetText(AIndex, ASubIndex: Integer; AItem: TListItem; const AText: String);
|
|
procedure ItemSetImage(AIndex, ASubIndex: Integer; AItem: TListItem);
|
|
procedure ItemSetState(const AIndex: Integer; const {%H-}AItem: TListItem; const AState: TListItemState;
|
|
const AIsSet: Boolean);
|
|
function ItemGetState(const AIndex: Integer; const {%H-}AItem: TListItem; const AState: TListItemState;
|
|
out AIsSet: Boolean): Boolean;
|
|
procedure setItemWidth(const AImageListWidth: integer=0); //calculates width of vsIcon item. Param aWidth is imageList.Width
|
|
procedure ScrollToRow(const ARow: integer);
|
|
procedure UpdateImageCellsSize;
|
|
|
|
property Images: TFPList read FImages write FImages;
|
|
property IsTreeView: Boolean read FIsTreeView;
|
|
end;
|
|
|
|
{ TGtk3Box }
|
|
|
|
TGtk3Box = class(TGtk3Container)
|
|
|
|
end;
|
|
|
|
{ TGtk3StatusBar }
|
|
|
|
TGtk3StatusBar = class(TGtk3Box)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
end;
|
|
|
|
{ TGtk3Panel }
|
|
|
|
TGtk3Panel = class(TGtk3Bin)
|
|
private
|
|
FBorderStyle: TBorderStyle;
|
|
procedure SetBorderStyle(AValue: TBorderStyle);
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
procedure DoBeforeLCLPaint; override;
|
|
procedure setText(const AValue: String); override;
|
|
public
|
|
property BorderStyle: TBorderStyle read FBorderStyle write SetBorderStyle;
|
|
end;
|
|
|
|
{ TGtk3GroupBox }
|
|
|
|
TGtk3GroupBox = class(TGtk3Bin)
|
|
strict private
|
|
class procedure GroupBoxSizeAllocate(AWidget: PGtkWidget; AGdkRect: PGdkRectangle; Data: gpointer); cdecl; static;
|
|
private
|
|
FGroupBoxType:TGtk3GroupBoxType;
|
|
function GetInnerClientRect(Frame:PGtkWidget):TRect;
|
|
protected
|
|
procedure DoBeforeLCLPaint; override;
|
|
procedure ConnectSizeAllocateSignal(ToWidget: PGtkWidget); override;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
function getText: String; override;
|
|
procedure setText(const AValue: String); override;
|
|
public
|
|
function getClientRect:TRect; override;
|
|
property GroupBoxType: TGtk3GroupBoxType read FGroupBoxType write FGroupBoxType;
|
|
end;
|
|
|
|
{ TGtk3ComboBox }
|
|
|
|
TGtk3ComboBox = class(TGtk3Bin)
|
|
private
|
|
FCellView: PGtkCellView;
|
|
function GetItemIndex: Integer;
|
|
procedure SetDroppedDown(AValue: boolean);
|
|
procedure SetItemIndex(AValue: Integer);
|
|
function GetDroppedDown: boolean;
|
|
strict private
|
|
class procedure ComboSizeAllocate(AWidget: PGtkWidget; AGdkRect: PGdkRectangle; Data: gpointer); cdecl; static;
|
|
class procedure ComboBoxChanged({%H-}ACombo: PGtkComboBox; AData: gpointer); cdecl; static;
|
|
class procedure NotifySignal(AObject: PGObject; pspec: PGParamSpec; AData: GPointer); cdecl; static;
|
|
protected
|
|
procedure ConnectSizeAllocateSignal(ToWidget:PGtkWidget);override;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
function EatArrowKeys(const AKey: Word): Boolean; override;
|
|
function getText: String; override;
|
|
procedure setText(const AValue: String); override;
|
|
public
|
|
procedure DumpPrivateStructValues(const ADbgEvent: String);
|
|
public
|
|
function CanFocus: Boolean; override;
|
|
procedure SetBounds(ALeft,ATop,AWidth,AHeight:integer); override;
|
|
procedure SetFocus; override;
|
|
function GetCellView: PGtkCellView;
|
|
function GetPopupWidget: PGtkWidget;
|
|
function GetButtonWidget: PGtkWidget;
|
|
function GetArrowWidget: PGtkWidget;
|
|
function getSelStart: integer;
|
|
function getSelLength: integer;
|
|
function getMaxLength: integer;
|
|
procedure SetMaxLength(const AMaxLength: integer);
|
|
procedure SetSelStart(const ANewStart: integer);
|
|
procedure SetSelLength(const ANewLength: integer);
|
|
procedure InitializeWidget; override;
|
|
property DroppedDown: boolean read GetDroppedDown write SetDroppedDown;
|
|
property ItemIndex: Integer read GetItemIndex write SetItemIndex;
|
|
end;
|
|
|
|
{ TGtk3Button }
|
|
|
|
TGtk3Button = class(TGtk3Bin)
|
|
private
|
|
FMargin: Integer;
|
|
FLayout: Integer;
|
|
FSpacing: Integer;
|
|
FImage: TBitmap;
|
|
function getLayout: Integer;
|
|
function getMargin: Integer;
|
|
procedure SetLayout(AValue: Integer);
|
|
procedure SetMargin(AValue: Integer);
|
|
procedure SetSpacing(AValue: Integer);
|
|
strict private
|
|
class function ButtonMouseEvent(aWidget: PGtkWidget; aEvent: PGdkEvent;
|
|
aData: gpointer): gboolean; cdecl; static;
|
|
protected
|
|
procedure SetImage(AImage:TBitmap);
|
|
function getText: String; override;
|
|
procedure setText(const AValue: String); override;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
destructor Destroy; override;
|
|
procedure InitializeWidget; override;
|
|
function IsWidgetOk: Boolean; override;
|
|
procedure SetDefault(const ADefault: Boolean);
|
|
property Layout: Integer read getLayout write SetLayout;
|
|
property Margin: Integer read getMargin write SetMargin;
|
|
property Spacing: Integer read FSpacing write SetSpacing;
|
|
property Image:TBitmap read fImage write SetImage;
|
|
end;
|
|
|
|
{ TGtk3ToggleButton }
|
|
|
|
TGtk3ToggleButton = class(TGtk3Button)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
end;
|
|
|
|
{ TGtk3CheckBox }
|
|
|
|
TGtk3CheckBox = class(TGtk3ToggleButton)
|
|
private
|
|
function GetState: TCheckBoxState;
|
|
procedure SetState(AValue: TCheckBoxState);
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure SetBounds(ALeft,ATop,AWidth,AHeight:integer); override;
|
|
property State: TCheckBoxState read GetState write SetState;
|
|
end;
|
|
|
|
{ TGtk3RadioButton }
|
|
|
|
TGtk3RadioButton = class(TGtk3CheckBox)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
function getClientRect:TRect; override;
|
|
procedure InitializeWidget; override;
|
|
end;
|
|
|
|
{ TGtk3CustomControl }
|
|
|
|
TGtk3CustomControl = class(TGtk3ScrollableWin)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
function EatArrowKeys(const {%H-}AKey: Word): Boolean; override;
|
|
public
|
|
procedure DoBeforeLCLPaint; override;
|
|
procedure OffsetMousePos(APoint: PPoint); override;
|
|
procedure InitializeWidget; override;
|
|
function getViewport: PGtkViewport; override;
|
|
procedure preferredSize(var PreferredWidth, PreferredHeight: integer; {%H-}WithThemeSpace: Boolean); override;
|
|
function getClientRect: TRect; override;
|
|
function getHorizontalScrollbar: PGtkScrollbar; override;
|
|
function getVerticalScrollbar: PGtkScrollbar; override;
|
|
function GetScrolledWindow: PGtkScrolledWindow; override;
|
|
end;
|
|
|
|
{ TGtk3ScrollingWinControl }
|
|
|
|
TGtk3ScrollingWinControl = class(TGtk3CustomControl)
|
|
strict private
|
|
class procedure ScrollingWinControlFixedSizeAllocate(AWidget: PGtkWidget;
|
|
AGdkRect: PGdkRectangle; Data: gpointer); cdecl; static;
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
end;
|
|
|
|
{ TGtk3Splitter }
|
|
|
|
TGtk3Splitter = class(TGtk3Panel)
|
|
public
|
|
end;
|
|
|
|
|
|
{ TGtk3Window }
|
|
|
|
TGtk3Window = class(TGtk3ScrollableWin) {we are TGtk3Bin actually, but it won't hurt since we need scroll}
|
|
private
|
|
FIcon: PGdkPixBuf;
|
|
FScrollWin: PGtkScrolledWindow;
|
|
FMenuBar: PGtkMenuBar;
|
|
FBox: PGtkBox;
|
|
function GetSkipTaskBarHint: Boolean;
|
|
function GetTitle: String;
|
|
procedure SetIcon(AValue: PGdkPixBuf);
|
|
procedure SetSkipTaskBarHint(AValue: Boolean);
|
|
procedure SetTitle(const AValue: String);
|
|
strict private
|
|
class function WindowMapEvent(awidget:PGtkWindow;AEvent: PGdkEventAny; adata: gpointer): gboolean; cdecl; static; //uses lcl-window-first-map data.
|
|
class procedure WindowSizeAllocate(AWidget: PGtkWidget; AGdkRect: PGdkRectangle; Data: gpointer); cdecl; static;
|
|
class function WindowStateSignal(AWidget: PGtkWidget; AEvent: PGdkEvent; AData: gPointer): gboolean; cdecl; static;
|
|
protected
|
|
FFirstMapRect: TRect;
|
|
procedure ConnectSizeAllocateSignal(ToWidget: PGtkWidget); override;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
function EatArrowKeys(const {%H-}AKey: Word): Boolean; override;
|
|
function getText: String; override;
|
|
procedure setText(const AValue: String); override;
|
|
public
|
|
// function getClientBounds: TRect; override;
|
|
function getViewport: PGtkViewport; override;
|
|
function getClientRect: TRect; override;
|
|
function getHorizontalScrollbar: PGtkScrollbar; override;
|
|
function getVerticalScrollbar: PGtkScrollbar; override;
|
|
function GetScrolledWindow: PGtkScrolledWindow; override;
|
|
procedure InitializeWidget; override;
|
|
procedure OffsetMousePos(APoint: PPoint); override;
|
|
function ShowState(nstate:integer):boolean; // winapi ShowWindow
|
|
procedure UpdateWindowState; // LCL WindowState
|
|
class function decoration_flags(Aform: TCustomForm): TGdkWMDecoration;
|
|
public
|
|
procedure DoBeforeLCLPaint; override;
|
|
procedure SetBounds(ALeft,ATop,AWidth,AHeight:integer); override;
|
|
destructor Destroy; override;
|
|
procedure Activate; override;
|
|
procedure ActivateWindow(AEvent: PGdkEvent);
|
|
function CloseQuery: Boolean;
|
|
function GetWindow: PGdkWindow; override;
|
|
function GetMenuBar: PGtkMenuBar;
|
|
function GetBox: PGtkBox;
|
|
function GetWindowState: TGdkWindowState;
|
|
property Icon: PGdkPixBuf read FIcon write SetIcon;
|
|
property SkipTaskBarHint: Boolean read GetSkipTaskBarHint write SetSkipTaskBarHint;
|
|
property Title: String read GetTitle write SetTitle;
|
|
end;
|
|
|
|
{ TGtk3HintWindow }
|
|
|
|
TGtk3HintWindow = class(TGtk3Window)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
end;
|
|
|
|
{ TGtk3Dialog }
|
|
|
|
TGtk3Dialog = class(TGtk3Widget)
|
|
private
|
|
class function CloseCB(dlg:TGtk3Dialog): GBoolean; cdecl;
|
|
class function CloseQueryCB(w:PGtkWidget;dlg:TGtk3Dialog): GBoolean; cdecl;
|
|
class function DestroyCB(dlg:TGtk3Dialog): GBoolean; cdecl;
|
|
class function ResponseCB(response_id:gint; dlg: TGtk3Dialog): GBoolean; cdecl;
|
|
class function RealizeCB(dlg:TGtk3Dialog): GBoolean; cdecl;
|
|
protected
|
|
function response_handler(response_id:TGtkResponseType):boolean; virtual;
|
|
function close_handler():boolean; virtual;
|
|
procedure SetCallbacks; virtual;
|
|
function CreateWidget(const {%H-}Params: TCreateParams):PGtkWidget; override;
|
|
public
|
|
CommonDialog: TCommonDialog;
|
|
procedure InitializeWidget; override;
|
|
procedure CloseDialog; virtual;
|
|
end;
|
|
|
|
{ TGtk3FileDialog }
|
|
|
|
TGtk3FileDialog = class(TGtk3Dialog)
|
|
private
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams): PGtkWidget; override;
|
|
public
|
|
constructor Create(const ACommonDialog: TCommonDialog); virtual; overload;
|
|
end;
|
|
|
|
{ TGtk3FontSelectionDialog }
|
|
|
|
TGtk3FontSelectionDialog = class(TGtk3Dialog)
|
|
protected
|
|
function response_handler(resp_id:TGtkResponseType):boolean; override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
constructor Create(const ACommonDialog: TCommonDialog); virtual; overload;
|
|
end;
|
|
|
|
{ TGtk3ColorSelectionDialog }
|
|
|
|
TGtk3ColorSelectionDialog = class(TGtk3Dialog)
|
|
public
|
|
procedure InitializeWidget; override;
|
|
constructor Create(const ACommonDialog: TCommonDialog); virtual; overload;
|
|
end;
|
|
|
|
{ TGtk3newColorSelectionDialog }
|
|
|
|
TGtk3newColorSelectionDialog = class(TGtk3Dialog)
|
|
protected
|
|
function response_handler(resp_id:TGtkResponseType):boolean; override;
|
|
public
|
|
constructor Create(const ACommonDialog: TCommonDialog); virtual; overload;
|
|
procedure InitializeWidget; override;
|
|
class procedure color_to_rgba(clr:TColor;out rgba:TgdkRGBA);
|
|
class function rgba_to_color(const rgba:TgdkRGBA):TColor;
|
|
end;
|
|
|
|
{ TGtk3GLArea }
|
|
TGtk3GLArea = class(TGtk3Widget)
|
|
protected
|
|
function CreateWidget(const {%H-}Params: TCreateParams): PGtkWidget; override;
|
|
public
|
|
procedure Update({%H-}ARect: PRect); override;
|
|
end;
|
|
|
|
{ TGtk3DesignWidget }
|
|
|
|
TGtk3DesignWidget = class(TGtk3Window)
|
|
protected
|
|
FDesignContext: HDC;
|
|
procedure BringDesignerToFront;
|
|
procedure ResizeDesigner;
|
|
function CreateWidget(const {%H-}Params: TCreateParams): PGtkWidget; override;
|
|
function GetContext: HDC; override;
|
|
public
|
|
procedure InitializeWidget; override;
|
|
function GtkEventPaint(Sender: PGtkWidget; AContext: Pcairo_t): Boolean; override; cdecl;
|
|
procedure lowerWidget; override;
|
|
procedure raiseWidget; override;
|
|
property DesignContext: HDC read FDesignContext;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses {$IFDEF GTK3DEBUGKEYPRESS}TypInfo,{$ENDIF}gtk3int, gtk3caret, imglist,
|
|
uriparser, lclproc, LazLogger;
|
|
|
|
const
|
|
|
|
GDK_DEFAULT_EVENTS_MASK = [
|
|
GDK_EXPOSURE_MASK, {2}
|
|
GDK_POINTER_MOTION_MASK, {4}
|
|
GDK_POINTER_MOTION_HINT_MASK, {8}
|
|
GDK_BUTTON_MOTION_MASK, {16}
|
|
GDK_BUTTON1_MOTION_MASK, {32}
|
|
GDK_BUTTON2_MOTION_MASK, {64}
|
|
GDK_BUTTON3_MOTION_MASK, {128}
|
|
GDK_BUTTON_PRESS_MASK, {256}
|
|
GDK_BUTTON_RELEASE_MASK, {512}
|
|
GDK_KEY_PRESS_MASK, {1024}
|
|
GDK_KEY_RELEASE_MASK, {2048}
|
|
GDK_ENTER_NOTIFY_MASK, {4096}
|
|
GDK_LEAVE_NOTIFY_MASK, {8192}
|
|
GDK_FOCUS_CHANGE_MASK, {16384}
|
|
GDK_STRUCTURE_MASK, {32768}
|
|
GDK_PROPERTY_CHANGE_MASK, {65536}
|
|
GDK_VISIBILITY_NOTIFY_MASK, {131072}
|
|
GDK_PROXIMITY_IN_MASK, {262144}
|
|
GDK_PROXIMITY_OUT_MASK, {524288}
|
|
GDK_SUBSTRUCTURE_MASK, {1048576}
|
|
GDK_SCROLL_MASK, {2097152}
|
|
GDK_TOUCH_MASK {4194304}
|
|
// GDK_SMOOTH_SCROLL_MASK {8388608} //there is a bug in GTK3, see https://stackoverflow.com/questions/11775161/gtk3-get-mouse-scroll-direction
|
|
];
|
|
|
|
function Gtk3EventToStr(AEvent: TGdkEventType): String;
|
|
begin
|
|
Result := 'GDK_NOTHING';
|
|
case AEvent of
|
|
GDK_DELETE: Result := 'GDK_DELETE';
|
|
GDK_DESTROY: Result := 'GDK_DESTROY';
|
|
GDK_EXPOSE: Result := 'GDK_EXPOSE';
|
|
GDK_MOTION_NOTIFY: Result := 'GDK_MOTION_NOTIFY';
|
|
GDK_BUTTON_PRESS: Result := 'GDK_BUTTON_PRESS';
|
|
GDK_2BUTTON_PRESS: Result := 'GDK_2BUTTON_PRESS';
|
|
GDK_3BUTTON_PRESS: Result := 'GDK_3BUTTON_PRESS';
|
|
GDK_BUTTON_RELEASE: Result := 'GDK_BUTTON_RELEASE';
|
|
GDK_KEY_PRESS: Result := 'GDK_KEY_PRESS';
|
|
GDK_KEY_RELEASE: Result := 'GDK_KEY_RELEASE';
|
|
GDK_ENTER_NOTIFY: Result := 'GDK_ENTER_NOTIFY';
|
|
GDK_LEAVE_NOTIFY: Result := 'GDK_LEAVE_NOTIFY';
|
|
GDK_FOCUS_CHANGE: Result := 'GDK_FOCUS_CHANGE';
|
|
GDK_CONFIGURE: Result := 'GDK_CONFIGURE';
|
|
GDK_MAP: Result := 'GDK_MAP';
|
|
GDK_UNMAP: Result := 'GDK_UNMAP';
|
|
GDK_PROPERTY_NOTIFY: Result := 'GDK_PROPERTY_NOTIFY';
|
|
GDK_SELECTION_CLEAR: Result := 'GDK_SELECTION_CLEAR';
|
|
GDK_SELECTION_REQUEST: Result := 'GDK_SELECTION_REQUEST';
|
|
GDK_SELECTION_NOTIFY: Result := 'GDK_SELECTION_NOTIFY';
|
|
GDK_PROXIMITY_IN: Result := 'GDK_PROXIMITY_IN';
|
|
GDK_PROXIMITY_OUT: Result := 'GDK_PROXIMITY_OUT';
|
|
GDK_DRAG_ENTER: Result := 'GDK_DRAG_ENTER';
|
|
GDK_DRAG_LEAVE: Result := 'GDK_DRAG_LEAVE';
|
|
GDK_DRAG_MOTION_: Result := 'GDK_DRAG_MOTION_';
|
|
GDK_DRAG_STATUS_: Result := 'GDK_DRAG_STATUS_';
|
|
GDK_DROP_START: Result := 'GDK_DROP_START';
|
|
GDK_DROP_FINISHED: Result := 'GDK_DROP_FINISHED';
|
|
GDK_CLIENT_EVENT: Result := 'GDK_CLIENT_EVENT';
|
|
GDK_VISIBILITY_NOTIFY: Result := 'GDK_VISIBILITY_NOTIFY';
|
|
GDK_SCROLL: Result := 'GDK_SCROLL';
|
|
GDK_WINDOW_STATE: Result := 'GDK_WINDOW_STATE';
|
|
GDK_SETTING: Result := 'GDK_SETTING';
|
|
GDK_OWNER_CHANGE: Result := 'GDK_OWNER_CHANGE';
|
|
GDK_GRAB_BROKEN: Result := 'GDK_GRAB_BROKEN';
|
|
GDK_DAMAGE: Result := 'GDK_DAMAGE';
|
|
GDK_TOUCH_BEGIN: Result := 'GDK_TOUCH_BEGIN';
|
|
GDK_TOUCH_UPDATE: Result := 'GDK_TOUCH_UPDATE';
|
|
GDK_TOUCH_END: Result := 'GDK_TOUCH_END';
|
|
GDK_TOUCH_CANCEL: Result := 'GDK_TOUCH_CANCEL';
|
|
GDK_EVENT_LAST: Result := 'GDK_EVENT_LAST';
|
|
else
|
|
Result := 'UNKNOWN GDK EVENT';
|
|
end;
|
|
end;
|
|
|
|
function GtkModifierStateToShiftState(AState: TGdkModifierType;
|
|
AIsKeyEvent: Boolean): Cardinal;
|
|
begin
|
|
Result := 0;
|
|
if GDK_SHIFT_MASK in AState then
|
|
Result := Result or MK_SHIFT;
|
|
if GDK_CONTROL_MASK in AState then
|
|
Result := Result or MK_CONTROL;
|
|
if GDK_MOD1_MASK in AState then
|
|
begin
|
|
if AIsKeyEvent then
|
|
Result := Result or KF_ALTDOWN
|
|
else
|
|
Result := Result or MK_ALT;
|
|
end;
|
|
end;
|
|
|
|
{$i gtk3lclcombobox.inc}
|
|
{$i gtk3lclentry.inc}
|
|
{$i gtk3lclbutton.inc}
|
|
{$i gtk3lclspinbutton.inc}
|
|
{$i gtk3lclframe.inc}
|
|
{$i gtk3lclnotebook.inc}
|
|
|
|
class function TGtk3Widget.WidgetEvent(widget: PGtkWidget; event: PGdkEvent; data: GPointer): gboolean; cdecl;
|
|
begin
|
|
{$IFDEF GTK3DEBUGCOMBOBOX}
|
|
if (Data <> nil) and (wtComboBox in TGtk3Widget(Data).WidgetType) and
|
|
(event^.type_ <> GDK_MOTION_NOTIFY) then
|
|
begin
|
|
if (Widget = TGtk3ComboBox(Data).GetPopupWidget) then
|
|
DebugLn('***** TGtk3Widget.WidgetEvent(MENU triggered ',dbgsName(TGtk3Widget(Data).LCLObject),
|
|
' ',Gtk3EventToStr(event^.type_))
|
|
else
|
|
if (Widget = TGtk3ComboBox(Data).GetButtonWidget) then
|
|
DebugLn('***** TGtk3Widget.WidgetEvent(BUTTON triggered ',dbgsName(TGtk3Widget(Data).LCLObject),
|
|
' ',Gtk3EventToStr(event^.type_))
|
|
else
|
|
if (Widget = PGtkWidget(TGtk3ComboBox(Data).GetCellView)) then
|
|
DebugLn('***** TGtk3Widget.WidgetEvent(CELLVIEW triggered ',dbgsName(TGtk3Widget(Data).LCLObject),
|
|
' ',Gtk3EventToStr(event^.type_))
|
|
else
|
|
if (Widget = TGtk3ComboBox(Data).Widget) then
|
|
DebugLn('***** TGtk3Widget.WidgetEvent(EVENTBOX triggered ',dbgsName(TGtk3Widget(Data).LCLObject),
|
|
' ',Gtk3EventToStr(event^.type_));
|
|
end;
|
|
{$ENDIF}
|
|
{$IFDEF GTK3DEBUGCORE}
|
|
// if event^.type_ = GDK_EXPOSE then
|
|
if event^.type_ <> GDK_MOTION_NOTIFY then
|
|
DebugLn('TGtk3Widget.WidgetEvent triggered ',dbgsName(TGtk3Widget(Data).LCLObject),
|
|
' ',Gtk3EventToStr(event^.type_));
|
|
{$ENDIF}
|
|
Result := gtk_false;
|
|
if Assigned(Application) and Application.Terminated then
|
|
exit;
|
|
case event^.type_ of
|
|
GDK_DELETE:
|
|
begin
|
|
// DebugLn('****** GDK_DELETE FOR ',dbgsName(TGtk3Widget(Data).LCLObject),' main_level=',dbgs(gtk_main_level));
|
|
if wtWindow in TGtk3Widget(Data).WidgetType then
|
|
begin
|
|
TGtk3Window(Data).CloseQuery;
|
|
// let lcl destroy widget
|
|
Result := True;
|
|
end;
|
|
end;
|
|
GDK_DESTROY:
|
|
begin
|
|
// DebugLn('****** GDK_DESTROY FOR ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_EXPOSE:
|
|
begin
|
|
DebugLn('****** GDK_EXPOSE FOR ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
// Gtk3DrawWidget is attached to 'draw' signal, Expose event doesn't trigger
|
|
// under gtk3.
|
|
// we use 'draw' signal Gtk3DrawEvent()
|
|
// Result := TGtk3Widget(Data).GtkEventPaint(Widget, Event);
|
|
end;
|
|
GDK_MOTION_NOTIFY:
|
|
begin
|
|
if wtWindow in TGtk3Widget(Data).WidgetType then
|
|
begin
|
|
if Widget = TGtk3Widget(Data).Widget then
|
|
exit;
|
|
end;
|
|
Result := TGtk3Widget(Data).GtkEventMouseMove(Widget, Event);
|
|
end;
|
|
GDK_BUTTON_PRESS:
|
|
begin
|
|
// set focus before gtk does that, so we have same behaviour as other ws
|
|
if TGtk3Widget(Data).GetFocusableByMouse and
|
|
not TGtk3Widget(Data).LCLObject.Focused and
|
|
TGtk3Widget(Data).LCLObject.CanFocus then
|
|
begin
|
|
//FIXME: combobox updates popup-shown property too late
|
|
// so we dont know yet if its dropped down or not
|
|
if (wtComboBox in TGtk3Widget(Data).WidgetType) then
|
|
begin
|
|
TGtk3ComboBox(Data).DumpPrivateStructValues('GDK_BUTTON_PRESS btn='+IntToStr(Event^.button.button));
|
|
end;
|
|
if (wtWindow in TGtk3Widget(Data).WidgetType) then
|
|
begin
|
|
TGtk3Widget(Data).Activate;
|
|
end else
|
|
LCLIntf.SetFocus(HWND(TGtk3Widget(Data)));
|
|
end;
|
|
|
|
if TGtk3Widget(Data).LCLObject is TButtonControl then exit;
|
|
|
|
Result:=TGtk3Widget(Data).GtkEventMouse(Widget , Event);
|
|
end;
|
|
GDK_2BUTTON_PRESS:
|
|
begin
|
|
// set focus before gtk does that, so we have same behaviour as other ws
|
|
if TGtk3Widget(Data).GetFocusableByMouse and
|
|
not TGtk3Widget(Data).LCLObject.Focused and
|
|
TGtk3Widget(Data).LCLObject.CanFocus then
|
|
LCLIntf.SetFocus(HWND(TGtk3Widget(Data)));
|
|
|
|
if TGtk3Widget(Data).LCLObject is TButtonControl then exit;
|
|
Result := TGtk3Widget(Data).GtkEventMouse(Widget , Event);
|
|
end;
|
|
GDK_3BUTTON_PRESS:
|
|
begin
|
|
// set focus before gtk does that, so we have same behaviour as other ws
|
|
if TGtk3Widget(Data).GetFocusableByMouse and
|
|
not TGtk3Widget(Data).LCLObject.Focused and
|
|
TGtk3Widget(Data).LCLObject.CanFocus then
|
|
LCLIntf.SetFocus(HWND(TGtk3Widget(Data)));
|
|
|
|
if TGtk3Widget(Data).LCLObject is TButtonControl then exit;
|
|
|
|
|
|
Result := TGtk3Widget(Data).GtkEventMouse(Widget , Event);
|
|
end;
|
|
GDK_BUTTON_RELEASE:
|
|
begin
|
|
{if not ((csClickEvents in TGtk3Widget(Data).LCLObject.ControlStyle) and
|
|
(csClicked in TGtk3Widget(Data).LCLObject.ControlState)) then }
|
|
|
|
if TGtk3Widget(Data).LCLObject is TButtonControl then exit;
|
|
|
|
Result := TGtk3Widget(Data).GtkEventMouse(Widget , Event);
|
|
end;
|
|
GDK_KEY_PRESS:
|
|
begin
|
|
if Widget^.has_focus or Widget^.is_toplevel then
|
|
Result := TGtk3Widget(Data).GtkEventKey(Widget, Event, True);
|
|
end;
|
|
GDK_KEY_RELEASE:
|
|
begin
|
|
if Widget^.has_focus or Widget^.is_toplevel then // or (Widget = TGtk3Widget(data).GetContainerWidget) then
|
|
Result := TGtk3Widget(Data).GtkEventKey(Widget, Event, False);
|
|
end;
|
|
GDK_ENTER_NOTIFY:
|
|
begin
|
|
end;
|
|
GDK_LEAVE_NOTIFY:
|
|
begin
|
|
end;
|
|
GDK_FOCUS_CHANGE:
|
|
begin
|
|
if wtComboBox in TGtk3Widget(Data).WidgetType then
|
|
begin
|
|
TGtk3ComboBox(Data).DumpPrivateStructValues('GDK_FOCUS_CHANGE='+IntToStr(Event^.focus_change.in_));
|
|
//FIXME: combobox updates popup-shown property too late
|
|
// so we dont know yet if its dropped down or not
|
|
if TGtk3ComboBox(Data).DroppedDown then
|
|
exit;
|
|
end;
|
|
if not (csNoFocus in TCustomForm(TGtk3Widget(Data).LCLObject).ControlStyle) then
|
|
TGtk3Widget(Data).GtkEventFocus(Widget, Event);
|
|
end;
|
|
GDK_CONFIGURE:
|
|
begin
|
|
(* DOES NOT WORK AS DOCUMENTATION SAYS
|
|
if Data <> nil then
|
|
begin
|
|
if wtWindow in TGtk3Widget(Data).WidgetType then
|
|
begin
|
|
TGtk3Window(Data).ActivateWindow(Event);
|
|
DebugLn('** WindowState event ',dbgsName(TGtk3Widget(Data).LCLObject),' windowState=',dbgs(TGtk3Window(Data).GetWindowState));
|
|
end else
|
|
DebugLn('** WindowState event not wtWindow ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
*)
|
|
Result := TGtk3Widget(Data).GtkEventResize(Widget, Event);
|
|
end;
|
|
GDK_MAP:
|
|
begin
|
|
//DebugLn('****** GDK_MAP FOR ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_UNMAP:
|
|
begin
|
|
// DebugLn('****** GDK_UNMAP FOR ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_PROPERTY_NOTIFY:
|
|
begin
|
|
// DebugLn('****** GDK_PROPERTY_NOTIFY FOR ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_CLIENT_EVENT:
|
|
begin
|
|
// DebugLn('****** GDK_CLIENT_EVENT FOR ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_VISIBILITY_NOTIFY:
|
|
begin
|
|
// ONLY HERE WE CAN CATCH Activate/Deactivate but problem is that
|
|
// PGtkWindow does not update active property properly
|
|
// so PGtkWindow(Widget)^.is_active returns TRUE even if window isn't active anymore
|
|
if wtWindow in TGtk3Widget(Data).WidgetType then
|
|
TGtk3Window(Data).ActivateWindow(Event);
|
|
// Result := TGtk3Widget(Data).GtkEventShowHide(Widget, Event);
|
|
// DebugLn('****** GDK_VISIBILITY_NOTIFY FOR ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_SCROLL:
|
|
begin
|
|
// DebugLn('****** GDK_SCROLL ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
// Result := TGtk3Widget(Data).GtkEventMouseWheel(Widget, Event);
|
|
end;
|
|
GDK_WINDOW_STATE:
|
|
begin
|
|
// DebugLn('****** GDK_WINDOW_STATE FOR ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
// this doesn't work as expected ... must use GDK_CONFIGURE to get active status ?!?
|
|
end;
|
|
GDK_GRAB_BROKEN: //could be broken eg. because of popupmenu
|
|
begin
|
|
DebugLn('****** GDK_GRAB_BROKEN (no problem if popupmenu is activated) ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
otherwise
|
|
DebugLn('****** GDK unhandled event type ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
// DebugLn(event^.type_);
|
|
end;
|
|
end;
|
|
|
|
class function TGtk3Widget.DrawWidget(AWidget: PGtkWidget; AContext: Pcairo_t; Data: gpointer): gboolean; cdecl;
|
|
var
|
|
ARect: TGdkRectangle;
|
|
begin
|
|
Result := False;
|
|
if Data <> nil then
|
|
begin
|
|
gdk_cairo_get_clip_rectangle(AContext, @ARect);
|
|
Result := TGtk3Widget(Data).GtkEventPaint(AWidget, AContext);
|
|
end;
|
|
end;
|
|
|
|
class procedure TGtk3Widget.MapWidget(AWidget: PGtkWidget; Data: gPointer); cdecl;
|
|
var
|
|
Allocation: TGtkAllocation;
|
|
ARect: TRect;
|
|
AWindow: PGdkWindow;
|
|
xx,yy,w,h: Gint;
|
|
begin
|
|
AWidget^.get_allocation(@Allocation);
|
|
{$IFDEF GTK3DEBUGCORE}
|
|
DebugLn('**** Gtk3MapWidget ....',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
with Allocation do
|
|
DebugLn(' Allocation ',Format('x %d y %d w %d h %d',[x,y,width,height]));
|
|
{$ENDIF}
|
|
TGtk3Widget(Data).WidgetMapped := True;
|
|
ARect := TGtk3Widget(Data).LCLObject.BoundsRect;
|
|
{$IFDEF GTK3DEBUGCORE}
|
|
with ARect do
|
|
DebugLn(' Rect ',Format('x %d y %d w %d h %d',[Left,Top,Right - Left, Bottom - Top]));
|
|
{$ENDIF}
|
|
if ARect.Left<ARect.Right then ;
|
|
|
|
AWindow := AWidget^.get_window;
|
|
// at least TPanel needs this
|
|
if Gtk3IsGdkWindow(AWindow) and (g_object_get_data(AWindow,'lclwidget') = nil) then
|
|
g_object_set_data(AWindow,'lclwidget', TGtk3Widget(Data));
|
|
if (AWindow <> nil) and AWidget^.get_has_window then
|
|
begin
|
|
// do resize to lcl size when mapping widget
|
|
gdk_window_set_events(AWindow, GDK_DEFAULT_EVENTS_MASK);
|
|
{ if not (wtWindow in TGtk3Widget(Data).WidgetType) then
|
|
begin }
|
|
with TGtk3Widget(Data).LCLObject do
|
|
begin
|
|
xx := Left;
|
|
yy := Top;
|
|
w := Width;
|
|
h := Height;
|
|
end;
|
|
TGtk3Widget(Data).BeginUpdate;
|
|
AWindow^.move(xx, yy);
|
|
AWindow^.resize(w, h);
|
|
TGtk3Widget(Data).EndUpdate;
|
|
{ end else
|
|
begin
|
|
// DebugLn('TGtk3Window is mapped , setting lclwidget property to PGdkWindow ...');
|
|
// now we set 'lclwidget' to our window.
|
|
// g_object_set_data(AWindow,'lclwidget', TGtk3Widget(Data));
|
|
end;}
|
|
end else
|
|
begin
|
|
if wtMemo in TGtk3Widget(Data).WidgetType then
|
|
begin
|
|
// gdk_window_get_geometry(AWindow, @xx,@yy,@w,@h);
|
|
// gdk_window_get_position(AWindow, @xx,@yy);
|
|
// DebugLn(' ***** Window ',Format('x %d y %d w %d h %d',[xx,yy,w,h]),' lclobject ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function SubtractScroll(AWidget: PGtkWidget; APosition: TPoint): TPoint;
|
|
begin
|
|
Result := APosition;
|
|
if Gtk3IsScrolledWindow(AWidget) then
|
|
begin
|
|
with gtk_scrolled_window_get_hadjustment(PGtkScrolledWindow(AWidget))^ do
|
|
dec(Result.x, Trunc(value - lower));
|
|
with gtk_scrolled_window_get_vadjustment(PGtkScrolledWindow(AWidget))^ do
|
|
dec(Result.y, Trunc(value - lower));
|
|
end;
|
|
end;
|
|
|
|
class function TGtk3Widget.ScrollEvent(AWidget: PGtkWidget; AEvent: PGdkEvent; AData: GPointer): GBoolean; cdecl;
|
|
var
|
|
AWinControl: TWinControl;
|
|
AState: Cardinal;
|
|
ShiftState: TShiftState;
|
|
MappedXY: TPoint;
|
|
MessE : TLMMouseEvent;
|
|
begin
|
|
Result := False;
|
|
if AWidget=nil then ;
|
|
|
|
AWinControl := TGtk3Widget(AData).LCLObject;
|
|
|
|
if AEvent^.scroll.send_event = NO_PROPAGATION_TO_PARENT then
|
|
exit;
|
|
|
|
MappedXY := Point(Round(AEvent^.Scroll.X),Round(AEvent^.scroll.Y));
|
|
AState := GtkModifierStateToShiftState(AEvent^.scroll.state, False);
|
|
ShiftState := [];
|
|
if AState and MK_SHIFT <> 0 then
|
|
ShiftState := ShiftState + [ssShift];
|
|
if AState and MK_CONTROL <> 0 then
|
|
ShiftState := ShiftState + [ssCtrl];
|
|
if AState and MK_ALT <> 0 then
|
|
ShiftState := ShiftState + [ssAlt];
|
|
|
|
TGtk3Widget(AData).OffsetMousePos(@MappedXY);
|
|
|
|
FillChar(MessE{%H-},SizeOf(MessE),0);
|
|
MessE.Msg := LM_MOUSEWHEEL;
|
|
case AEvent^.scroll.direction of
|
|
GDK_SCROLL_UP, GDK_SCROLL_RIGHT {0}: MessE.WheelDelta := 120;
|
|
GDK_SCROLL_DOWN, GDK_SCROLL_LEFT {1}: MessE.WheelDelta := -120;
|
|
GDK_SCROLL_SMOOTH:
|
|
begin
|
|
if AEvent^.scroll.delta_y <> 0 then
|
|
begin
|
|
if AEvent^.scroll.delta_y > 0 then
|
|
MessE.WheelDelta := -120
|
|
else
|
|
MessE.WheelDelta := 120;
|
|
//TODO: find in settings default wheel scroll distance
|
|
//MessE.WheelDelta := -Round((120 * AEvent^.scroll.delta_y) / 10);
|
|
end else
|
|
if AEvent^.scroll.delta_x <> 0 then
|
|
begin
|
|
if AEvent^.scroll.delta_x > 0 then
|
|
MessE.WheelDelta := -120
|
|
else
|
|
MessE.WheelDelta := 120;
|
|
end else
|
|
exit;
|
|
end;
|
|
else
|
|
begin
|
|
DebugLn('WARNING: ',dbgsName(aWinControl),' unhandled scrollDirection event ',dbgs(Ord(AEvent^.scroll.direction)));
|
|
exit;
|
|
end;
|
|
end;
|
|
MessE.X := SmallInt(MappedXY.X);
|
|
MessE.Y := SmallInt(MappedXY.Y);
|
|
MessE.State := ShiftState;
|
|
MessE.UserData := AWinControl;
|
|
MessE.Button := 0;
|
|
|
|
NotifyApplicationUserInput(AWinControl, MessE.Msg);
|
|
Result := TGtk3Widget(AData).DeliverMessage(MessE) <> 0;
|
|
AEvent^.scroll.send_event := NO_PROPAGATION_TO_PARENT;
|
|
|
|
//DebugLn('Gtk3ScrollEvent for ', dbgsName(TGtk3Widget(AData).LCLObject),' Result ',dbgs(Result));
|
|
end;
|
|
|
|
class procedure TGtk3Widget.SizeAllocate(AWidget: PGtkWidget; AGdkRect: PGdkRectangle; Data: gpointer); cdecl;
|
|
var
|
|
Msg: TLMSize;
|
|
NewSize: TSize;
|
|
ACtl: TGtk3Widget;
|
|
AState: TGdkWindowState;
|
|
Alloc: TGtkAllocation;
|
|
begin
|
|
if AWidget=nil then ;
|
|
|
|
ACtl := TGtk3Widget(Data);
|
|
|
|
{$IFDEF GTK3DEBUGSIZE}
|
|
if Assigned(ACtl.LCLObject) then
|
|
begin
|
|
with ACtl.LCLObject do
|
|
writeln(Format('TGtk3Widget.SizeAllocate %s Gdk x %d y %d w %d h %d LCL l %d t %d w %d h %d applied w %d h %d cliRect %s',[dbgsName(ACtl.LCLObject), AGdkRect^.x, AGdkRect^.y, AGdkRect^.width, AGdkRect^.height, Left, Top, Width, Height, ACtl.LCLWidth, ACtl.LCLHeight, dbgs(ACtl.LCLObject.ClientRect)]));
|
|
end;
|
|
{$ENDIF}
|
|
// return size w/o frame
|
|
NewSize.cx := AGdkRect^.width;
|
|
NewSize.cy := AGdkRect^.height;
|
|
|
|
//writeln(format('Gkt3SizeAllocate w=%d h=%d',[NewSize.cx,NewSize.cy]));
|
|
|
|
if not Assigned(ACtl.LCLObject) then exit;
|
|
|
|
// do not loop with LCL !
|
|
if not (csDesigning in ACtl.LCLObject.ComponentState) then
|
|
begin
|
|
if ACtl.InUpdate then
|
|
exit;
|
|
|
|
if (ACtl.LCLWidth = NewSize.cx) and (ACtl.LCLHeight = NewSize.cy) and (ACtl.LCLWidth > 0) then
|
|
begin
|
|
if ACtl.LCLObject.ClientRectNeedsInterfaceUpdate then
|
|
ACtl.LCLObject.DoAdjustClientRectChange(True);
|
|
end;
|
|
end;
|
|
|
|
if ((NewSize.cx <> ACtl.LCLObject.Width) or (NewSize.cy <> ACtl.LCLObject.Height) or
|
|
ACtl.LCLObject.ClientRectNeedsInterfaceUpdate) then
|
|
ACtl.LCLObject.DoAdjustClientRectChange;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_SIZE;
|
|
Msg.SizeType := SIZE_RESTORED;
|
|
|
|
if ACtl is TGtk3Window then
|
|
begin
|
|
AState := TGtk3Window(ACtl).getWindowState;
|
|
if GDK_WINDOW_STATE_ICONIFIED in AState then
|
|
Msg.SizeType := SIZE_MINIMIZED
|
|
else
|
|
if GDK_WINDOW_STATE_MAXIMIZED in AState then
|
|
Msg.SizeType := SIZE_MAXIMIZED
|
|
else
|
|
if GDK_WINDOW_STATE_FULLSCREEN in AState then
|
|
Msg.SizeType := SIZE_FULLSCREEN;
|
|
|
|
end;
|
|
|
|
Msg.SizeType := Msg.SizeType or Size_SourceIsInterface;
|
|
|
|
if ACtl.WidgetType*[wtScrollBar, wtHintWindow]<>[] then
|
|
begin
|
|
Msg.Width := ACtl.LCLObject.Width;//Word(NewSize.cx);
|
|
Msg.Height := ACtl.LCLObject.Height;//Word(NewSize.cy);
|
|
end else
|
|
if {ACtl is TGtk3Window} ACtl.WidgetType*[wtWindow,wtDialog,
|
|
{wtScrollingWinControl,}wtScrollingWin,wtNotebook,wtContainer]<>[] then
|
|
begin
|
|
Msg.Width := Word(NewSize.cx);
|
|
Msg.Height := Word(NewSize.cy);
|
|
end else
|
|
begin
|
|
Msg.Width := ACtl.LCLObject.Width;//Word(NewSize.cx);
|
|
Msg.Height := ACtl.LCLObject.Height;//Word(NewSize.cy);
|
|
end;
|
|
|
|
ACtl.DeliverMessage(Msg);
|
|
|
|
end;
|
|
|
|
class procedure TGtk3Widget.WidgetHide({%H-}AWidget: PGtkWidget; AData: gpointer); cdecl;
|
|
var
|
|
Msg: TLMShowWindow;
|
|
Gtk3Widget: TGtk3Widget;
|
|
begin
|
|
Gtk3Widget := TGtk3Widget(AData);
|
|
{do not pass message to LCL if LCL setted up control visibility}
|
|
if Gtk3Widget.inUpdate then
|
|
exit;
|
|
// DebugLn('SEND LM_HIDE FOR ',dbgsName(Gtk3Widget.LCLObject));
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_SHOWWINDOW;
|
|
Msg.Show := False;
|
|
|
|
Gtk3Widget.DeliverMessage(Msg);
|
|
end;
|
|
|
|
class procedure TGtk3Widget.WidgetShow({%H-}AWidget: PGtkWidget; AData: gpointer); cdecl;
|
|
var
|
|
Msg: TLMShowWindow;
|
|
Gtk3Widget: TGtk3Widget;
|
|
begin
|
|
Gtk3Widget := TGtk3Widget(AData);
|
|
{do not pass message to LCL if LCL setted up control visibility}
|
|
if Gtk3Widget.inUpdate then
|
|
exit;
|
|
// DebugLn('SEND LM_SHOW FOR ',dbgsName(Gtk3Widget.LCLObject));
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_SHOWWINDOW;
|
|
Msg.Show := True;
|
|
|
|
Gtk3Widget.DeliverMessage(Msg);
|
|
end;
|
|
|
|
{ TGtk3SplitterSide }
|
|
|
|
function TGtk3SplitterSide.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
Result:=TGtkScrolledWindow.new(nil, nil);
|
|
end;
|
|
|
|
{ TGtk3Paned }
|
|
|
|
function TGtk3Paned.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
const
|
|
ornt:array[TPairSplitterType] of TGtkOrientation=(
|
|
GTK_ORIENTATION_HORIZONTAL,
|
|
GTK_ORIENTATION_VERTICAL
|
|
);
|
|
begin
|
|
Result:=TGtkPaned.new(ornt[TPairSplitter(Self.LCLObject).SplitterType]);
|
|
end;
|
|
|
|
{ TGtk3Widget }
|
|
|
|
function TGtk3Widget.GtkEventMouseMove(Sender: PGtkWidget; Event: PGdkEvent
|
|
): Boolean; cdecl;
|
|
var
|
|
Msg: TLMMouseMove;
|
|
MousePos: TPoint;
|
|
ADisplay: PGdkDisplay;
|
|
ASeat: PGdkSeat;
|
|
ADevice: PGdkDevice;
|
|
X, Y: gint;
|
|
AMask: TGdkModifierType;
|
|
{$IFDEF GTK3DEBUGEVENTS}
|
|
R: TRect;
|
|
{$ENDIF}
|
|
begin
|
|
Result := False;
|
|
|
|
{$IFDEF GTK3DEBUGEVENTS}
|
|
R := GetClientBounds;
|
|
DebugLn(['GtkEventMouseMove: ',dbgsName(LCLObject),' Send=',dbgs(Event^.motion.send_event),
|
|
' state=',dbgs(LongInt(event^.motion.state)),
|
|
' x=',dbgs(Round(event^.motion.x)),
|
|
' y=',dbgs(Round(event^.motion.y)),
|
|
' x_root=',dbgs(Round(event^.motion.x_root)),
|
|
' y_root=',dbgs(Round(event^.motion.y_root)),
|
|
' STOP PROCESSING ? ',dbgs(Event^.motion.send_event = NO_PROPAGATION_TO_PARENT),
|
|
' GtkBounds ',dbgs(R),' LCLBounds ',dbgs(LCLObject.BoundsRect),' W=',dbgs(LCLObject.Width)]
|
|
);
|
|
{$ENDIF}
|
|
|
|
if Event^.motion.send_event = NO_PROPAGATION_TO_PARENT then
|
|
exit;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
//we use GDK_POINTER_MOTION_HINT_MASK, so we cannot trust Event^.motion position
|
|
if Event^.motion.is_hint = 1 then
|
|
begin
|
|
ADisplay := gtk_widget_get_display(Sender);
|
|
ASeat := gdk_display_get_default_seat(ADisplay);
|
|
ADevice := gdk_seat_get_pointer(ASeat);
|
|
gdk_window_get_device_position(Event^.motion.window, ADevice, @X, @Y, @AMask);
|
|
end else
|
|
begin
|
|
X := Round(Event^.motion.x);
|
|
Y := Round(Event^.motion.y);
|
|
AMask := Event^.motion.state;
|
|
end;
|
|
|
|
MousePos.x := X;
|
|
MousePos.y := Y;
|
|
|
|
OffsetMousePos(@MousePos);
|
|
|
|
Msg.XPos := SmallInt(MousePos.X);
|
|
Msg.YPos := SmallInt(MousePos.Y);
|
|
|
|
if Mouse.CursorPos=MousePos then exit;
|
|
|
|
Msg.Keys := GdkModifierStateToLCL(aMask, False);
|
|
|
|
Msg.Msg := LM_MOUSEMOVE;
|
|
|
|
NotifyApplicationUserInput(LCLObject, Msg.Msg);
|
|
if Widget^.get_parent <> nil then
|
|
Event^.motion.send_event := NO_PROPAGATION_TO_PARENT;
|
|
DeliverMessage(Msg, True);
|
|
end;
|
|
|
|
function TGtk3Widget.GtkEventPaint(Sender: PGtkWidget; AContext: Pcairo_t
|
|
): Boolean; cdecl;
|
|
var
|
|
Msg: TLMPaint;
|
|
AStruct: TPaintStruct;
|
|
AClipRect: TGdkRectangle;
|
|
localClip:TRect;
|
|
//P: TPoint;
|
|
AScrolledWin: PGtkScrolledWindow;
|
|
ACaret: TGtk3Caret;
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
dx, dy: double;
|
|
allocation: TGtkAllocation;
|
|
{$ENDIF}
|
|
begin
|
|
Result := False;
|
|
|
|
if not FHasPaint then
|
|
exit;
|
|
|
|
if Self is TGtk3DesignWidget then
|
|
begin
|
|
//writeln('WARNING: DesignWidget should not be called here !');
|
|
exit;
|
|
end;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_PAINT;
|
|
FillChar(AStruct{%H-}, SizeOf(TPaintStruct), 0);
|
|
Msg.PaintStruct := @AStruct;
|
|
|
|
with PaintData do
|
|
begin
|
|
if GetContainerWidget = nil then
|
|
PaintWidget := Widget
|
|
else
|
|
PaintWidget := GetContainerWidget;
|
|
ClipRegion := nil;
|
|
gdk_cairo_get_clip_rectangle(AContext, @AClipRect);
|
|
|
|
{$IFDEF GTK3DEBUGEVENTS}
|
|
if (Self is TGtk3ScrollableWin) and not (LCLObject is TCustomForm) then
|
|
begin
|
|
//cairo_get_current_point(AContext, @dx, @dy);
|
|
cairo_user_to_device(AContext, @dx, @dy);
|
|
writeln(Format('PaintEvent: CairoClip %s dx %2.2n dy %2.2n',[dbgs(RectFromGdkRect(AClipRect)), dx, dy]));
|
|
end;
|
|
{$ENDIF}
|
|
|
|
localClip:=RectFromGdkRect(AClipRect);
|
|
ClipRect := @localClip;
|
|
end;
|
|
|
|
FCairoContext := AContext;
|
|
Msg.DC := BeginPaint(HWND(Self), AStruct);
|
|
FContext := Msg.DC;
|
|
|
|
Msg.PaintStruct^.rcPaint := PaintData.ClipRect^;
|
|
Msg.PaintStruct^.hdc := FContext;
|
|
|
|
try
|
|
try
|
|
//P := getClientOffset;
|
|
//cairo_translate(AContext, P.X, P.Y);
|
|
DoBeforeLCLPaint;
|
|
LCLObject.WindowProc(TLMessage(Msg));
|
|
if HasCaret and not (csDesigning in LCLObject.ComponentState) then
|
|
begin
|
|
ACaret := TGtk3Caret(g_object_get_data(Sender,'gtk3-caret'));
|
|
if ACaret.Visible then
|
|
ACaret.CairoDrawCaret(FCairoContext);
|
|
end;
|
|
finally
|
|
FCairoContext := nil;
|
|
Fillchar(FPaintData, SizeOf(FPaintData), 0);
|
|
FContext := 0;
|
|
EndPaint(HWND(Self), AStruct);
|
|
end;
|
|
except
|
|
Application.HandleException(nil);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.GtkEventResize(Sender: PGtkWidget; Event: PGdkEvent
|
|
): Boolean; cdecl;
|
|
begin
|
|
{$IF DEFINED(GTK3DEBUGEVENTS) OR DEFINED(GTK3DEBUGSIZE)}
|
|
DebugLn('GtkEventResize: ',dbgsName(LCLObject),' Send=',dbgs(Event^.configure.send_event),
|
|
' x=',dbgs(Round(event^.configure.x)),
|
|
' y=',dbgs(Round(event^.configure.y)),
|
|
' w=',dbgs(Round(event^.configure.width)),
|
|
' h=',dbgs(Round(event^.configure.height)));
|
|
{$ENDIF}
|
|
Result := false;
|
|
end;
|
|
|
|
procedure TGtk3Widget.GtkEventFocus(Sender: PGtkWidget; Event: PGdkEvent);
|
|
cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
ACaret: TGtk3Caret;
|
|
begin
|
|
{$IF DEFINED(GTK3DEBUGEVENTS) OR DEFINED(GTK3DEBUGFOCUS)}
|
|
DebugLn('TGtk3Widget.GtkEventFocus ',dbgsName(LCLObject),' FocusIn ',dbgs(Event^.focus_change.in_ <> 0));
|
|
{$ENDIF}
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
if Event^.focus_change.in_ <> 0 then
|
|
Msg.Msg := LM_SETFOCUS
|
|
else
|
|
Msg.Msg := LM_KILLFOCUS;
|
|
|
|
if HasCaret then
|
|
begin
|
|
ACaret := TGtk3Caret(g_object_get_data(PGObject(getContainerWidget),'gtk3-caret'));
|
|
if ACaret.RespondToFocus then
|
|
begin
|
|
if Msg.Msg = LM_SETFOCUS then
|
|
ACaret.Show
|
|
else
|
|
ACaret.Hide;
|
|
end;
|
|
end;
|
|
|
|
DeliverMessage(Msg);
|
|
end;
|
|
|
|
procedure TGtk3Widget.GtkEventDestroy; cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
Msg.Msg := LM_DESTROY;
|
|
DeliverMessage(Msg);
|
|
Release;
|
|
end;
|
|
|
|
function TGtk3Widget.IsValidHandle: Boolean;
|
|
begin
|
|
Result := Assigned(FWidget) and Gtk3IsWidget(FWidget) and not FWidget^.in_destruction;
|
|
end;
|
|
|
|
function TGtk3Widget.IsWidgetOk: Boolean;
|
|
begin
|
|
Result := Gtk3IsWidget(FWidget);
|
|
end;
|
|
|
|
function TGtk3Widget.IsIconic: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOk then
|
|
begin
|
|
if FWidget^.get_window <> nil then
|
|
Result := GDK_WINDOW_STATE_ICONIFIED in gdk_window_get_state(FWidget^.get_window);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.getType: TGType;
|
|
begin
|
|
Result := getContainerWidget^.g_type_instance.g_class^.g_type;
|
|
end;
|
|
|
|
function TGtk3Widget.getTypeName: PgChar;
|
|
begin
|
|
Result := g_type_name(getType);
|
|
end;
|
|
|
|
procedure TGtk3Widget.lowerWidget;
|
|
begin
|
|
if Gtk3IsGdkWindow(FWidget^.window) then
|
|
FWidget^.window^.lower;
|
|
end;
|
|
|
|
procedure TGtk3Widget.raiseWidget;
|
|
begin
|
|
if Gtk3IsGdkWindow(FWidget^.window) then
|
|
FWidget^.window^.raise_;
|
|
end;
|
|
|
|
procedure TGtk3Widget.stackUnder(AWidget: PGtkWidget);
|
|
begin
|
|
// FWidget^.
|
|
end;
|
|
|
|
function TGtk3Widget.GetCapture: TGtk3Widget;
|
|
var
|
|
AHandle: HWND;
|
|
begin
|
|
AHandle := HwndFromGtkWidget(gtk_grab_get_current);
|
|
if AHandle <> 0 then
|
|
Result := TGtk3Widget(AHandle);
|
|
end;
|
|
|
|
function TGtk3Widget.SetCapture: HWND;
|
|
begin
|
|
Result := HWND(GetCapture);
|
|
gtk_grab_add(GetContainerWidget);
|
|
end;
|
|
|
|
|
|
function TGtk3Widget.GtkEventKey(Sender: PGtkWidget; Event: PGdkEvent; AKeyPress: Boolean): Boolean;
|
|
cdecl;
|
|
const
|
|
CN_KeyDownMsgs: array[Boolean] of UINT = (CN_KEYDOWN, CN_SYSKEYDOWN);
|
|
CN_KeyUpMsgs: array[Boolean] of UINT = (CN_KEYUP, CN_SYSKEYUP);
|
|
LM_KeyDownMsgs: array[Boolean] of UINT = (LM_KEYDOWN, LM_SYSKEYDOWN);
|
|
LM_KeyUpMsgs: array[Boolean] of UINT = (LM_KEYUP, LM_SYSKEYUP);
|
|
CN_CharMsg: array[Boolean] of UINT = (CN_CHAR, CN_SYSCHAR);
|
|
LM_CharMsg: array[Boolean] of UINT = (LM_CHAR, LM_SYSCHAR);
|
|
var
|
|
AEvent: TGdkEventKey;
|
|
Msg: TLMKey;
|
|
CharMsg: TLMChar;
|
|
AEventString: String;
|
|
KeyValue, ACharCode: Word;
|
|
LCLModifiers: Word;
|
|
IsSysKey: Boolean;
|
|
UTF8Char: TUTF8Char;
|
|
AChar: Char;
|
|
IsArrowKey: Boolean;
|
|
TempWidget: HWND;
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
Info: PTypeInfo;
|
|
{$ENDIF}
|
|
begin
|
|
//TODO: finish LCL messaging
|
|
Result := False;
|
|
AEvent := Event^.key;
|
|
FillChar(Msg{%H-}, SizeOf(Msg), 0);
|
|
AEventString := AEvent.string_;
|
|
|
|
TempWidget := HwndFromGtkWidget(Sender);
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
if TempWidget = 0 then
|
|
writeln('***** warning: no gtk3widget ! *****')
|
|
else
|
|
writeln('GtkEventKey: Gtk3Widget ',dbgsName(TGtk3Widget(TempWidget)));
|
|
{$ENDIF}
|
|
|
|
if gdk_keyval_is_lower(AEvent.keyval) then
|
|
KeyValue := Word(gdk_keyval_to_upper(AEvent.keyval))
|
|
else
|
|
KeyValue := Word(AEvent.keyval);
|
|
// state=16 = numlock= on.
|
|
|
|
LCLModifiers := GtkModifierStateToShiftState(AEvent.state, True);
|
|
|
|
|
|
if length(AEventString) = 0 then
|
|
begin
|
|
if KeyValue = GDK_KEY_Alt_L then
|
|
LCLModifiers := LCLModifiers or KF_ALTDOWN
|
|
else
|
|
if (KeyValue = GDK_KEY_Control_L) or (KeyValue = GDK_KEY_Control_R) then
|
|
LCLModifiers := LCLModifiers or MK_CONTROL
|
|
else
|
|
if (KeyValue = GDK_KEY_Shift_L) or (KeyValue = GDK_KEY_Shift_R) then
|
|
LCLModifiers := LCLModifiers or MK_SHIFT;
|
|
// writeln('MODIFIERS BY KEYS ',LCLModifiers);
|
|
end;
|
|
|
|
IsSysKey := LCLModifiers and KF_ALTDOWN <> 0;
|
|
|
|
if not AKeyPress then
|
|
LCLModifiers := LCLModifiers or KF_UP;
|
|
|
|
// else
|
|
// writeln('KeyRelease: ',dbgsName(LCLObject),' Dump state=',AEvent.state,' hwkey=',KeyCode,' keyvalue=',KeyValue,' modifier=',AEvent.Bitfield0.is_modifier);
|
|
|
|
// this is just for testing purposes.
|
|
ACharCode := GdkKeyToLCLKey(KeyValue);
|
|
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
writeln('==== ACharCode=',ACharCode,' KeyValue=',KeyValue);
|
|
{$ENDIF}
|
|
|
|
if KeyValue > VK_UNDEFINED then
|
|
KeyValue := ACharCode; // VK_UNKNOWN;
|
|
|
|
if AKeyPress and (ACharCode = VK_TAB) then
|
|
begin
|
|
if Sender^.is_focus then
|
|
Self.LCLObject.SelectNext(Self.LCLObject,true,true);
|
|
exit;
|
|
end;
|
|
|
|
IsArrowKey := (AEventString='') and ((ACharCode = VK_UP) or (ACharCode = VK_DOWN) or (ACharCode = VK_LEFT) or (ACharCode = VK_RIGHT));
|
|
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
Info := TypeInfo(TGdkModifierType);
|
|
if AKeyPress then
|
|
writeln('EVENT KeyPress: ',dbgsName(LCLObject),' Dump state=',SetToString(Info, LongInt(AEvent.state), True),' keyvalue=',KeyValue,' modifier=',AEvent.Bitfield0.is_modifier,
|
|
' KeyValue ',KeyValue,' MODIFIERS ',LCLModifiers,' CharCode ',ACharCode,' EAT ',EatArrowKeys(ACharCode),' Window ? ',Sender^.window = GetWindow)
|
|
else
|
|
writeln('EVENT KeyRelease: ',dbgsName(LCLObject),' Dump state=',SetToString(Info, LongInt(AEvent.state), True),' keyvalue=',KeyValue,' modifier=',AEvent.Bitfield0.is_modifier,
|
|
' KeyValue ',KeyValue,' MODIFIERS ',LCLModifiers,' CharCode ',ACharCode,
|
|
' EAT ',EatArrowKeys(ACharCode));
|
|
{$ENDIF}
|
|
|
|
if (ACharCode <> VK_UNKNOWN) then
|
|
begin
|
|
if AKeyPress then
|
|
Msg.Msg := CN_KeyDownMsgs[IsSysKey]
|
|
else
|
|
Msg.Msg := CN_KeyUpMsgs[IsSysKey];
|
|
Msg.CharCode := ACharCode;
|
|
Msg.KeyData := PtrInt((KeyValue shl 16) or (LCLModifiers shl 16) or $0001);
|
|
|
|
NotifyApplicationUserInput(LCLObject, Msg.Msg);
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
|
|
if (DeliverMessage(Msg, True) <> 0) or (Msg.CharCode = VK_UNKNOWN) then
|
|
begin
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
writeln('<==== CN_KeyDownMsgs handled ... exiting');
|
|
{$ENDIF}
|
|
if ([wtEntry,wtMemo] * WidgetType <>[]) then
|
|
exit(false)
|
|
else
|
|
exit(True);
|
|
end;
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
|
|
if AKeyPress then
|
|
Msg.Msg := LM_KeyDownMsgs[IsSysKey]
|
|
else
|
|
Msg.Msg := LM_KeyUpMsgs[IsSysKey];
|
|
Msg.CharCode := ACharCode;
|
|
Msg.KeyData := PtrInt((KeyValue shl 16) or (LCLModifiers shl 16) or $0001);
|
|
|
|
NotifyApplicationUserInput(LCLObject, Msg.Msg);
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
|
|
{$warning workaround for GtkTreeView key bindings.Must find out what LCL does with
|
|
this keys.}
|
|
if {IsArrowKey and} ([wtListBox,wtListView,wtEntry,wtMemo] * WidgetType <> []) then
|
|
// let gtk3 select cell for now. Must check what LCL does with arrow keys
|
|
// since gtk3 becomes crazy after delivery of this message
|
|
else
|
|
if (DeliverMessage(Msg, True) <> 0) or (Msg.CharCode = 0) then
|
|
begin
|
|
Result := (Msg.CharCode = 0) or IsArrowKey;
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
writeln('<=== LM_KeyDownMsgs handled ... exiting ',dbgs(ACharCode),' Result=',dbgs(Result),' AKeyPress=',dbgs(AKeyPress));
|
|
{$ENDIF}
|
|
exit;
|
|
end;
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
end;
|
|
|
|
if AKeyPress and (length(AEventString) > 0) then
|
|
begin
|
|
UTF8Char := AEventString;
|
|
// TODO: If not IsControlKey
|
|
Result := LCLObject.IntfUTF8KeyPress(UTF8Char, 1, IsSysKey);
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
|
|
if Result then
|
|
begin
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
writeln('LCLObject.IntfUTF8KeyPress handled ... exiting');
|
|
{$ENDIF}
|
|
exit;
|
|
end;
|
|
|
|
// create the CN_CHAR / CN_SYSCHAR message
|
|
FillChar(CharMsg{%H-}, SizeOf(CharMsg), 0);
|
|
CharMsg.Msg := CN_CharMsg[IsSysKey];
|
|
CharMsg.KeyData := Msg.KeyData;
|
|
AChar := AEventString[1];
|
|
CharMsg.CharCode := Word(AChar);
|
|
NotifyApplicationUserInput(LCLObject, CharMsg.Msg);
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
|
|
Result := (DeliverMessage(CharMsg, True) <> 0) or (CharMsg.CharCode = VK_UNKNOWN) or IsArrowKey;
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
|
|
if Result then
|
|
begin
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
writeln('<=== CN_CharMsg handled ... exiting');
|
|
{$ENDIF}
|
|
exit;
|
|
end;
|
|
|
|
//Send a LM_(SYS)CHAR
|
|
CharMsg.Msg := LM_CharMsg[IsSysKey];
|
|
|
|
NotifyApplicationUserInput(LCLObject, CharMsg.Msg);
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
|
|
DeliverMessage(CharMsg, True);
|
|
|
|
if not CanSendLCLMessage then
|
|
exit;
|
|
end;
|
|
if AKeyPress then
|
|
begin
|
|
{$IFDEF GTK3DEBUGKEYPRESS}
|
|
if (Msg.CharCode in FKeysToEat) then
|
|
begin
|
|
writeln('EVENT: ******* KeyPress charcode is in keys to eat (FKeysToEat), charcode=',dbgs(Msg.CharCode),' window ? ',Sender^.window = Self.GetWindow);
|
|
end else
|
|
writeln('EVENT: KeyPress Result = False Window ? ', Sender^.window = Self.GetWindow);
|
|
{$ENDIF}
|
|
Result := (TempWidget = GetFocus) and (Msg.CharCode in FKeysToEat);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.GtkEventMouse(Sender: PGtkWidget; Event: PGdkEvent): Boolean;
|
|
cdecl;
|
|
var
|
|
Msg: TLMMouse;
|
|
MsgPopup : TLMMouse;
|
|
MousePos: TPoint;
|
|
MButton: guint;
|
|
SavedHandle: PtrUInt;
|
|
begin
|
|
Result := gtk_false;
|
|
{$IF DEFINED(GTK3DEBUGEVENTS) OR DEFINED(GTK3DEBUGMOUSE)}
|
|
writeLn('TGtk3Widget.GtkEventMouse ',dbgsName(LCLObject),
|
|
' propagate=',dbgs(not (Event^.button.send_event = NO_PROPAGATION_TO_PARENT)),' Exit ? ',Event^.button.send_event = NO_PROPAGATION_TO_PARENT,
|
|
' Event.Type=',Event^.type_,' Capture=',LCLintf.GetCapture);
|
|
{$ENDIF}
|
|
if Event^.button.send_event = NO_PROPAGATION_TO_PARENT then
|
|
exit(gtk_true);
|
|
|
|
SavedHandle := PtrUInt(Self);
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Keys := GdkModifierStateToLCL(Event^.button.state, False);
|
|
|
|
MousePos.x := Round(Event^.button.x);
|
|
MousePos.y := Round(Event^.button.y);
|
|
|
|
OffsetMousePos(@MousePos);
|
|
|
|
Msg.XPos := SmallInt(MousePos.X);
|
|
Msg.YPos := SmallInt(MousePos.Y);
|
|
|
|
MButton := Event^.button.button;
|
|
|
|
case Event^.type_ of
|
|
GDK_BUTTON_PRESS:
|
|
begin
|
|
if MButton = GTK3_LEFT_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_LBUTTONDOWN;
|
|
Msg.Keys := Msg.Keys or MK_LBUTTON;
|
|
end
|
|
else
|
|
if MButton = GTK3_RIGHT_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_RBUTTONDOWN;
|
|
Msg.Keys := Msg.Keys or MK_RBUTTON;
|
|
end
|
|
else
|
|
if MButton = GTK3_MIDDLE_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_MBUTTONDOWN;
|
|
Msg.Keys := Msg.Keys or MK_MBUTTON;
|
|
end;
|
|
end;
|
|
GDK_2BUTTON_PRESS: //-> double click GDK_DOUBLE_BUTTON_PRESS
|
|
begin
|
|
if MButton = GTK3_LEFT_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_LBUTTONDBLCLK;
|
|
Msg.Keys := Msg.Keys or MK_LBUTTON;
|
|
end
|
|
else
|
|
if MButton = GTK3_RIGHT_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_RBUTTONDBLCLK;
|
|
Msg.Keys := Msg.Keys or MK_RBUTTON;
|
|
end
|
|
else
|
|
if MButton = GTK3_MIDDLE_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_MBUTTONDBLCLK;
|
|
Msg.Keys := Msg.Keys or MK_MBUTTON;
|
|
end;
|
|
end;
|
|
GDK_BUTTON_RELEASE:
|
|
begin
|
|
if MButton = GTK3_LEFT_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_LBUTTONUP;
|
|
Msg.Keys := Msg.Keys or MK_LBUTTON;
|
|
end
|
|
else
|
|
if MButton = GTK3_RIGHT_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_RBUTTONUP;
|
|
Msg.Keys := Msg.Keys or MK_RBUTTON;
|
|
end
|
|
else
|
|
if MButton = GTK3_MIDDLE_BUTTON then
|
|
begin
|
|
Msg.Msg := LM_MBUTTONUP;
|
|
Msg.Keys := Msg.Keys or MK_MBUTTON;
|
|
end;
|
|
end;
|
|
else
|
|
DebugLn(Format('WARNING: GtkEventMouse() unhandled event type %d.',[Ord(Event^.type_)]))
|
|
end;
|
|
|
|
{$IF DEFINED(GTK3DEBUGEVENTS) OR DEFINED(GTK3DEBUGMOUSE)}
|
|
DebugLn('TGtk3Widget.GtkEventMouse ',dbgsName(LCLObject),
|
|
' msg=',dbgs(msg.Msg), ' point=',dbgs(Msg.XPos),',',dbgs(Msg.YPos));
|
|
{$ENDIF}
|
|
NotifyApplicationUserInput(LCLObject, Msg.Msg);
|
|
Event^.button.send_event := NO_PROPAGATION_TO_PARENT;
|
|
|
|
Result := False;
|
|
|
|
if Msg.Msg = LM_RBUTTONDOWN then
|
|
begin
|
|
MsgPopup := Msg;
|
|
MsgPopup.Msg := LM_CONTEXTMENU;
|
|
MsgPopup.XPos := SmallInt(Round(Event^.button.x_root));
|
|
MsgPopup.YPos := SmallInt(Round(Event^.button.y_root));
|
|
|
|
if (SavedHandle <> PtrUInt(Self)) or (LCLObject = nil) or (FWidget = nil) then
|
|
exit;
|
|
|
|
Result := DeliverMessage(MsgPopup, True) <> 0;
|
|
end;
|
|
|
|
if not Result then
|
|
begin
|
|
if (SavedHandle <> PtrUInt(Self)) or (LCLObject = nil) or (FWidget = nil) then
|
|
exit;
|
|
Result := DeliverMessage(Msg, True) <> 0;
|
|
end;
|
|
if wtPanel in WidgetType then
|
|
Result := GDK_EVENT_STOP;
|
|
end;
|
|
|
|
function TGtk3Widget.GetVisible: Boolean;
|
|
begin
|
|
Result := Assigned(FWidget) and FWidget^.visible;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetEnabled(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOK then
|
|
FWidget^.set_sensitive(AValue);
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetFont(AValue: PPangoFontDescription);
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
GetContainerWidget^.override_font(AValue);
|
|
if Assigned(FFont) and (FFont <> AValue) then
|
|
FFont^.free;
|
|
FFont := AValue;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetShape(AValue: PGdkPixbuf);
|
|
begin
|
|
if FShape=AValue then Exit;
|
|
if FShape <> nil then
|
|
FShape^.unref;
|
|
FShape := AValue;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetFontColor(AValue: TColor);
|
|
var
|
|
AColor: TGdkRGBA;
|
|
i: TGtkStateType;
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
AColor := TColortoTGdkRGBA(ColorToRgb(AValue));
|
|
if FWidget <> GetContainerWidget then
|
|
begin
|
|
with FWidget^ do
|
|
begin
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
override_color(TGtkStateFlags(1 shl (i - 1)), @AColor);
|
|
end;
|
|
end;
|
|
with GetContainerWidget^ do
|
|
begin
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
override_color(TGtkStateFlags(1 shl (i - 1)), @AColor);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetColor(AValue: TColor);
|
|
var
|
|
AColor: TGdkRGBA;
|
|
i: TGtkStateType;
|
|
ARgba: TGdkRGBA;
|
|
begin
|
|
// new way (gtk3) but still buggy
|
|
if IsWidgetOK and (0 > 1) then
|
|
begin
|
|
if AValue = clDefault then
|
|
begin
|
|
(*
|
|
with FDefaultRGBA do
|
|
begin
|
|
writeln('clDefault ',Format('R %2.2n G %2.2n B %2.2n A %2.2n',[R, G, B , Alpha]));
|
|
ARgba.red := R;
|
|
ARgba.green := G;
|
|
ARgba.blue := B;
|
|
ARgba.alpha := Alpha;
|
|
end;
|
|
*)
|
|
end else
|
|
begin
|
|
ARgba := TColortoTGdkRGBA(ColorToRGB(AValue));
|
|
{$info GTK3: set GdkRGBA.alpah to 1.0?}
|
|
|
|
{ColorToCairoRGB(ColorToRGB(AValue), R, G, B);
|
|
ARgba.red := R;
|
|
ARgba.green := G;
|
|
ARgba.blue := B;
|
|
ARgba.alpha := 1.0;}
|
|
end;
|
|
if FWidget <> GetContainerWidget then
|
|
begin
|
|
with FWidget^ do
|
|
begin
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
begin
|
|
if AValue = clDefault then
|
|
begin
|
|
ARgba.red := FWidgetRGBA[i].R;
|
|
ARgba.green := FWidgetRGBA[i].G;
|
|
ARgba.blue := FWidgetRGBA[i].B;
|
|
ARgba.alpha := FWidgetRGBA[i].Alpha;
|
|
end;
|
|
FWidget^.override_background_color(TGtkStateFlags(1 shl (i - 1)), @ARgba);
|
|
end;
|
|
end;
|
|
end;
|
|
with GetContainerWidget^ do
|
|
begin
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
begin
|
|
//if AVAlue = clDefault then
|
|
// GetContainerWidget^.get_style_context^.get_background_color(GTK_STATE_NORMAL, @ARgba);
|
|
if AValue = clDefault then
|
|
begin
|
|
ARgba.red := FCentralWidgetRGBA[i].R;
|
|
ARgba.green := FCentralWidgetRGBA[i].G;
|
|
ARgba.blue := FCentralWidgetRGBA[i].B;
|
|
ARgba.alpha := FCentralWidgetRGBA[i].Alpha;
|
|
end;
|
|
GetContainerWidget^.override_background_color(TGtkStateFlags(1 shl (i - 1)), @ARgba);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if IsWidgetOK then
|
|
begin
|
|
AColor := TColortoTGdkRGBA(ColorToRgb(AValue));
|
|
if FWidget <> GetContainerWidget then
|
|
begin
|
|
with FWidget^ do
|
|
begin
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
if AValue = clDefault then
|
|
override_background_color(TGtkStateFlags(1 shl (i - 1)), nil)
|
|
else
|
|
override_background_color(TGtkStateFlags(1 shl (i - 1)), @AColor);
|
|
end;
|
|
end;
|
|
with GetContainerWidget^ do
|
|
begin
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
begin
|
|
if AValue = clDefault then
|
|
override_background_color(TGtkStateFlags(1 shl (i - 1)), nil)
|
|
else
|
|
override_background_color(TGtkStateFlags(1 shl (i - 1)), @AColor);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.GetStyleContext: PGtkStyleContext;
|
|
begin
|
|
Result := nil;
|
|
if IsWidgetOK then
|
|
Result := GetContainerWidget^.get_style_context;
|
|
end;
|
|
|
|
function TGtk3Widget.GetFont: PPangoFontDescription;
|
|
var
|
|
AContext: PPangoContext;
|
|
begin
|
|
Result := nil;
|
|
if IsWidgetOK then
|
|
begin
|
|
AContext := GetContainerWidget^.get_pango_context;
|
|
Result := pango_context_get_font_description(AContext);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.CanSendLCLMessage: Boolean;
|
|
begin
|
|
Result := IsWidgetOk and (LCLObject <> nil);
|
|
end;
|
|
|
|
function TGtk3Widget.GetCairoContext: Pcairo_t;
|
|
begin
|
|
Result := FCairoContext;
|
|
end;
|
|
|
|
function TGtk3Widget.GetEnabled: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOK then
|
|
Result := FWidget^.get_sensitive;
|
|
end;
|
|
|
|
function TGtk3Widget.GetFontColor: TColor;
|
|
var
|
|
AStyle: PGtkStyleContext;
|
|
AGdkRGBA: TGdkRGBA;
|
|
begin
|
|
Result := clDefault;
|
|
if IsWidgetOK then
|
|
begin
|
|
AStyle := GetStyleContext;
|
|
AStyle^.get_background_color(GTK_STATE_FLAG_NORMAL, @AGdkRGBA);
|
|
Result := TGdkRGBAToTColor(AGdkRGBA);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.GetColor: TColor;
|
|
var
|
|
AStyle: PGtkStyleContext;
|
|
AColor: TGdkRGBA;
|
|
begin
|
|
Result := clDefault;
|
|
if IsWidgetOK then
|
|
begin
|
|
AStyle := GetStyleContext;
|
|
AStyle^.get_background_color(GTK_STATE_FLAG_NORMAL, @AColor);
|
|
Result := TGdkRGBAToTColor(AColor);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetStyleContext(AValue: PGtkStyleContext);
|
|
begin
|
|
{$NOTE Gtk3: Find a nice way to assign StyleContext}
|
|
{if IsWidgetOK then
|
|
GetContainerWidget^.set_style(AValue);}
|
|
end;
|
|
|
|
class procedure TGtk3Widget.DestroyWidgetEvent(w: PGtkWidget; data: gpointer); cdecl;
|
|
begin
|
|
{$IFDEF GTK3DEBUGCORE}
|
|
writeln('DestroyWidgetEvent entered ',Assigned(w),' Data ? ',Assigned(data));
|
|
{$ENDIF}
|
|
if Assigned(data) then
|
|
TGtk3Widget(Data).FWidget:=nil;
|
|
end;
|
|
|
|
function TGtk3Widget.getText: String;
|
|
begin
|
|
Result := fText; // default text storage
|
|
end;
|
|
|
|
procedure TGtk3Widget.setText(const AValue: String);
|
|
begin
|
|
fText:=AValue;
|
|
// DebugLn('WARNING: ',dbgsName(LCLObject),' self=',dbgsName(Self),' does not implement setText !');
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetVisible(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOK then
|
|
FWidget^.Visible := AValue;
|
|
end;
|
|
|
|
function TGtk3Widget.QueryInterface(constref iid: TGuid; out obj): LongInt; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
|
|
begin
|
|
if GetInterface(iid, obj) then
|
|
Result := 0
|
|
else
|
|
Result := E_NOINTERFACE;
|
|
end;
|
|
|
|
function TGtk3Widget._AddRef: LongInt; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
|
|
begin
|
|
Result := -1; // no ref counting
|
|
end;
|
|
|
|
function TGtk3Widget._Release: LongInt; {$IFDEF WINDOWS}stdcall{$ELSE}cdecl{$ENDIF};
|
|
begin
|
|
Result := -1;
|
|
end;
|
|
|
|
function TGtk3Widget.IsDesigning: boolean;
|
|
begin
|
|
Result := Assigned(LCLObject) and (csDesigning in LCLObject.ComponentState)
|
|
and not (Self is TGtk3DesignWidget);
|
|
end;
|
|
|
|
function TGtk3Widget.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := AKey in [VK_LEFT, VK_UP, VK_RIGHT, VK_DOWN];
|
|
end;
|
|
|
|
function TGtk3Widget.GetContext: HDC;
|
|
begin
|
|
Result := FContext;
|
|
end;
|
|
|
|
function TGtk3Widget.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
Result := PGtkWidget(TGtkWidget.newv(32, 0 ,nil));
|
|
end;
|
|
|
|
function TGtk3Widget.GetWidget:PGtkWidget;
|
|
begin
|
|
Result := FWidget;
|
|
end;
|
|
|
|
procedure TGtk3Widget.DestroyWidget;
|
|
var
|
|
ATemp: PGtkWidget;
|
|
begin
|
|
if HasCaret and IsValidHandle then
|
|
GTK3WidgetSet.DestroyCaret(HWND(Self));
|
|
|
|
if IsValidHandle and FOwnWidget then
|
|
begin
|
|
FOwnWidget:=false;
|
|
{$IFDEF GTK3DEBUGCORE}
|
|
DbgOut(#10'destroying '+Classname+' ... ');
|
|
{$ENDIF}
|
|
ATemp := FWidget;
|
|
FWidget := nil;
|
|
ATemp^.destroy_;
|
|
{$IFDEF GTK3DEBUGCORE}
|
|
DbgOut(Classname+' destroyed.'+#10);
|
|
{$ENDIF}
|
|
end;
|
|
FWidget := nil;
|
|
if Assigned(FShape) then
|
|
begin
|
|
FShape^.unref;
|
|
FShape := nil;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.DoBeforeLCLPaint;
|
|
begin
|
|
//
|
|
end;
|
|
|
|
constructor TGtk3Widget.Create(const AWinControl: TWinControl;
|
|
const AParams: TCreateParams);
|
|
begin
|
|
inherited Create;
|
|
LCLWidth := 0;
|
|
LCLHeight := 0;
|
|
FContext := 0;
|
|
FWidgetMapped := False;
|
|
FHasPaint := False;
|
|
FWidget := nil;
|
|
FOwner := nil;
|
|
FCentralWidget := nil;
|
|
FOwnWidget := True;
|
|
// Initializes the properties
|
|
FProps := nil;
|
|
LCLObject := AWinControl;
|
|
FKeysToEat := [VK_TAB, VK_RETURN, VK_ESCAPE];
|
|
// FHasPaint := False;
|
|
|
|
FParams := AParams;
|
|
InitializeWidget;
|
|
end;
|
|
|
|
constructor TGtk3Widget.CreateFrom(const AWinControl: TWinControl;
|
|
AWidget: PGtkWidget);
|
|
begin
|
|
inherited Create;
|
|
FContext := 0;
|
|
FWidgetMapped := False;
|
|
FHasPaint := False;
|
|
FWidget := nil;
|
|
FOwner := nil;
|
|
FCentralWidget := nil;
|
|
FOwnWidget := False;
|
|
// Initializes the properties
|
|
FProps := nil;
|
|
LCLObject := AWinControl;
|
|
FWidget := AWidget;
|
|
// FKeysToEat := [VK_TAB, VK_RETURN, VK_ESCAPE];
|
|
// FHasPaint := False;
|
|
end;
|
|
|
|
class function TGtk3Widget.MouseEnterNotify(aWidget: PGtkWidget; aEvent: PGdkEventCrossing; aData: gpointer): gboolean; cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
Result := gtk_false;
|
|
Msg.Msg := LM_MOUSEENTER;
|
|
TGtk3Widget(aData).DeliverMessage(Msg, True);
|
|
if Assigned(TGtk3Widget(aData).LCLObject) and (csDesigning in TGtk3Widget(aData).LCLObject.ComponentState) then
|
|
Result := gtk_true;
|
|
end;
|
|
|
|
class function TGtk3Widget.MouseLeaveNotify(aWidget: PGtkWidget; aEvent: PGdkEventCrossing; aData: gpointer): gboolean; cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
Result := gtk_false;
|
|
Msg.Msg := LM_MOUSELEAVE;
|
|
|
|
if Gtk3IsLayout(aWidget) and (aWidget^.get_parent = TGtk3Widget(aData).Widget) then
|
|
exit;
|
|
TGtk3Widget(aData).DeliverMessage(Msg, True);
|
|
if Assigned(TGtk3Widget(aData).LCLObject) and (csDesigning in TGtk3Widget(aData).LCLObject.ComponentState) then
|
|
Result := gtk_true;
|
|
end;
|
|
|
|
class procedure TGtk3Widget.DragDataReceived(aWidget:PGtkWidget; aContext: PGdkDragContext;
|
|
x:gint; y:gint; selection_data: PGtkSelectionData; info:guint; time:guint; aData: gPointer);cdecl;
|
|
var
|
|
S: TStringList;
|
|
I: Integer;
|
|
FileName, DecodedFileName: String;
|
|
Files: array of String;
|
|
Form: TControl;
|
|
Result: Boolean;
|
|
U: TURI;
|
|
begin
|
|
Result := gtk_false;
|
|
if selection_data^.get_data <> nil then // data is list of uri
|
|
try
|
|
SetLength(Files{%H-}, 0);
|
|
S := TStringList.Create;
|
|
try
|
|
S.Text := PChar(selection_data^.get_data);
|
|
|
|
for i := 0 to S.Count - 1 do
|
|
begin
|
|
FileName := S[I];
|
|
|
|
if FileName = '' then Continue;
|
|
// uri = protocol://hostname/file name
|
|
U := ParseURI(FileName);
|
|
if (SameText(U.Host, 'localhost') or (U.Host = '')) and SameText(U.Protocol, 'file')
|
|
and URIToFileName(FileName, DecodedFileName) then // convert uri of local files to file name
|
|
begin
|
|
FileName := DecodedFileName;
|
|
end;
|
|
// otherwise: protocol and hostname are preserved!
|
|
|
|
if FileName = '' then Continue;
|
|
SetLength(Files, Length(Files) + 1);
|
|
Files[High(Files)] := FileName;
|
|
//DebugLn('GtkDragDataReceived ' + DbgS(I) + ': ' + PChar(FileName));
|
|
end;
|
|
finally
|
|
S.Free;
|
|
end;
|
|
|
|
if Length(Files) > 0 then
|
|
begin
|
|
Form := nil;
|
|
if (TObject(TGtk3Widget(aData).LCLObject) is TWinControl) then
|
|
Form := TWinControl(TGtk3Widget(aData).LCLObject).IntfGetDropFilesTarget;
|
|
|
|
if Form is TCustomForm then
|
|
TCustomForm(Form).IntfDropFiles(Files)
|
|
else
|
|
if (Application <> nil) and (Application.MainForm <> nil) then
|
|
Application.MainForm.IntfDropFiles(Files);
|
|
|
|
if Application <> nil then
|
|
Application.IntfDropFiles(Files);
|
|
|
|
Result := gtk_true;
|
|
end;
|
|
except
|
|
Application.HandleException(nil);
|
|
end;
|
|
|
|
gtk_drag_finish(aContext, Result, false, time);
|
|
end;
|
|
|
|
procedure TGtk3Widget.InitializeWidget;
|
|
var
|
|
ARect: TGdkRectangle;
|
|
ARgba: TGdkRGBA;
|
|
i: TGtkStateType;
|
|
begin
|
|
FHasCaret := False;
|
|
FFocusableByMouse := False;
|
|
FCentralWidget := nil;
|
|
FCairoContext := nil;
|
|
FContext := 0;
|
|
FEnterLeaveTime := 0;
|
|
FShape := nil;
|
|
|
|
FWidgetType := [wtWidget];
|
|
FWidget := CreateWidget(FParams);
|
|
|
|
if not (wtWindow in FWidgetType) then
|
|
begin
|
|
FWidget^.show_all;
|
|
with ARect do
|
|
begin
|
|
x := LCLObject.Left;
|
|
y := LCLObject.Top;
|
|
width := LCLObject.Width;
|
|
height := LCLObject.Height;
|
|
end;
|
|
FWidget^.set_allocation(@ARect);
|
|
end;
|
|
LCLIntf.SetProp(HWND(Self),'lclwidget',Self);
|
|
|
|
// connect events
|
|
// move signal connections into attach events
|
|
if not gtk_widget_get_realized(FWidget) then
|
|
FWidget^.set_events(GDK_DEFAULT_EVENTS_MASK);
|
|
g_signal_connect_data(FWidget, 'destroy', TGCallback(@DestroyWidgetEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(FWidget, 'event', TGCallback(@WidgetEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
g_signal_connect_data(GetContainerWidget, 'enter-notify-event', TGCallback(@MouseEnterNotify), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(getContainerWidget, 'leave-notify-event', TGCallback(@MouseLeaveNotify), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
g_signal_connect_data(FWidget,'drag_data_received',TGCallback(@DragDataReceived), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
begin
|
|
FWidget^.get_style_context^.get_background_color(TGtkStateFlags(1 shl (i - 1)), @ARgba);
|
|
with FWidgetRGBA[i] do
|
|
begin
|
|
R := ARgba.red;
|
|
G := ARgba.green;
|
|
B := ARgba.blue;
|
|
Alpha := ARgba.alpha;
|
|
end;
|
|
end;
|
|
|
|
if (FCentralWidget <> nil) and (FCentralWidget <> FWidget) then
|
|
begin
|
|
FCentralWidget^.set_events(GDK_DEFAULT_EVENTS_MASK);
|
|
g_signal_connect_data(FCentralWidget, 'event', TGCallback(@WidgetEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
begin
|
|
FCentralWidget^.get_style_context^.get_background_color(TGtkStateFlags(1 shl (i - 1)), @ARgba);
|
|
with FCentralWidgetRGBA[i] do
|
|
begin
|
|
R := ARgba.red;
|
|
G := ARgba.green;
|
|
B := ARgba.blue;
|
|
Alpha := ARgba.alpha;
|
|
end;
|
|
end;
|
|
end else
|
|
begin
|
|
for i := GTK_STATE_NORMAL to GTK_STATE_INSENSITIVE do
|
|
FCentralWidgetRGBA[i] := FWidgetRGBA[i];
|
|
end;
|
|
FDrawSignal := g_signal_connect_data(GetContainerWidget,'draw', TGCallback(@DrawWidget), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(GetContainerWidget,'scroll-event', TGCallback(@ScrollEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
// must hide all by default ???
|
|
//FWidget^.hide;
|
|
|
|
g_signal_connect_data(FWidget,'hide', TGCallback(@WidgetHide), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(FWidget,'show', TGCallback(@WidgetShow), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(FWidget,'map', TGCallback(@MapWidget), Self, nil, G_CONNECT_DEFAULT);
|
|
ConnectSizeAllocateSignal(FWidget);
|
|
if IsDesigning then
|
|
begin
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
writeln('Designer: initializing ',dbgsName(Self),' LCLObj=',dbgsName(LCLobject),' set can focus to false.');
|
|
{$ENDIF}
|
|
gtk_widget_set_can_focus(Widget, False);
|
|
gtk_widget_set_can_focus(GetContainerWidget, False);
|
|
end;
|
|
// g_signal_connect_data(FWidget, 'motion_notify_event', TGCallback(@Gtk3MotionNotifyEvent), LCLObject, nil, 0);
|
|
end;
|
|
|
|
procedure TGtk3Widget.ConnectSizeAllocateSignal(ToWidget:PGtkWidget);
|
|
begin
|
|
g_signal_connect_data(ToWidget,'size-allocate',TGCallback(@SizeAllocate), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
procedure TGtk3Widget.DeInitializeWidget;
|
|
begin
|
|
|
|
end;
|
|
|
|
procedure TGtk3Widget.RecreateWidget;
|
|
begin
|
|
|
|
end;
|
|
|
|
procedure TGtk3Widget.DestroyNotify(AWidget: PGtkWidget);
|
|
begin
|
|
|
|
end;
|
|
|
|
destructor TGtk3Widget.Destroy;
|
|
begin
|
|
DestroyWidget;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
function TGtk3Widget.CanFocus: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOK then
|
|
Result := FWidget^.can_focus or GetContainerWidget^.can_focus;
|
|
end;
|
|
|
|
function TGtk3Widget.GetFocusableByMouse: Boolean;
|
|
begin
|
|
Result := FFocusableByMouse;
|
|
end;
|
|
|
|
function TGtk3Widget.getClientOffset: TPoint;
|
|
var
|
|
Allocation: TGtkAllocation;
|
|
R: TRect;
|
|
begin
|
|
{offset between inner and outer rect of widget.
|
|
It tricky since some widgets have regular offset eg
|
|
Parent (FWidget) = (120,80) Child (FCentralWidget) = (2,2)
|
|
but some are
|
|
Parent (FWidget) = (120,80) Child (FCentralWidget) = (122,82).
|
|
Such widgets are usually those with FCentralWidget^.get_has_window}
|
|
Result := Point(0, 0);
|
|
if Widget <> getContainerWidget then
|
|
begin
|
|
GetContainerWidget^.get_allocation(@Allocation);
|
|
Result.X := Allocation.X;
|
|
Result.Y := Allocation.Y;
|
|
end else
|
|
exit;
|
|
R := getClientBounds;
|
|
Result := Point(Result.x + R.Left, Result.y + R.Top);
|
|
end;
|
|
|
|
function TGtk3Widget.getWidgetPos: TPoint;
|
|
var
|
|
Allocation: TGtkAllocation;
|
|
begin
|
|
Result := Point(0, 0);
|
|
if IsWidgetOk then
|
|
begin
|
|
FWidget^.get_allocation(@Allocation);
|
|
Result := Point(Allocation.X, Allocation.Y);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.OffsetMousePos(APoint: PPoint);
|
|
begin
|
|
with getClientOffset do
|
|
begin
|
|
dec(APoint^.x, x);
|
|
dec(APoint^.y, y);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.ClientToScreen(var P: TPoint): boolean;
|
|
var
|
|
TempAlloc: TGtkAllocation;
|
|
Pt: TPoint;
|
|
w,tw:PgtkWidget;
|
|
x,y:integer;
|
|
gw:PgdkWindow;
|
|
begin
|
|
Result := False;
|
|
Pt := Point(0, 0);
|
|
|
|
if not IsWidgetOk then
|
|
begin
|
|
DebugLn('TGtk3Widget.ClientToScreen invalid widget ...');
|
|
exit;
|
|
end;
|
|
|
|
{ most usable source
|
|
https://stackoverflow.com/questions/2088962/how-do-you-find-the-absolute-position-of-a-gtk-widget-in-a-window
|
|
}
|
|
|
|
w:=fWidget;
|
|
tw:=w^.get_toplevel;
|
|
gw:=tw^.window;
|
|
while Assigned(w) {and (w<>tw)} do
|
|
begin
|
|
w^.get_allocation(@TempAlloc);
|
|
pt.X:=pt.X+TempAlloc.X;
|
|
pt.Y:=pt.Y+TempAlloc.Y;
|
|
w:=w^.parent;
|
|
end;
|
|
|
|
gw^.get_origin(@x,@y);
|
|
pt.x+=x;
|
|
pt.y+=y;
|
|
p:=pt;
|
|
Result:=true;
|
|
|
|
end;
|
|
|
|
function TGtk3Widget.ScreenToClient(var P: TPoint): Integer;
|
|
var
|
|
AGtkWidget: PGtkWidget;
|
|
AWindow: PGdkWindow;
|
|
X,Y: Integer;
|
|
Allocation: TGtkAllocation;
|
|
begin
|
|
Result:=-1;
|
|
AGtkWidget := GetContainerWidget;
|
|
if Assigned(AGtkWidget) and Gtk3IsGdkWindow(AGtkWidget^.window) then
|
|
begin
|
|
AWindow := AGtkWidget^.window;
|
|
PGdkWindow(AWindow)^.get_origin(@X, @Y);
|
|
AGtkWidget^.get_allocation(@Allocation);
|
|
if not AGtkWidget^.get_has_window and (AGtkWidget^.get_parent <> nil) then
|
|
begin
|
|
AGtkWidget^.get_allocation(@Allocation);
|
|
P.X := P.X - X - Allocation.x;
|
|
P.Y := P.Y - Y - Allocation.y;
|
|
exit;
|
|
end;
|
|
end else
|
|
if Gtk3IsGdkWindow(fWidget^.window) then
|
|
begin
|
|
AWindow := fWidget^.window;
|
|
PGdkWindow(AWindow)^.get_origin(@X, @Y);
|
|
end else
|
|
begin
|
|
fWidget^.get_allocation(@Allocation);
|
|
P.X := P.X - X - Allocation.x;
|
|
P.Y := P.Y - Y - Allocation.y;
|
|
exit;
|
|
end;
|
|
dec(P.X, X);
|
|
dec(P.Y, Y);
|
|
end;
|
|
|
|
function TGtk3Widget.DeliverMessage(var Msg; const AIsInputEvent: Boolean
|
|
): LRESULT;
|
|
begin
|
|
Result := LRESULT(AIsInputEvent);
|
|
if LCLObject = nil then
|
|
Exit;
|
|
try
|
|
if LCLObject.HandleAllocated then
|
|
begin
|
|
LCLObject.WindowProc(TLMessage(Msg));
|
|
Result := TLMessage(Msg).Result;
|
|
end;
|
|
except
|
|
Application.HandleException(nil);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.getClientRect: TRect;
|
|
var
|
|
AAlloc: TGtkAllocation;
|
|
begin
|
|
Result := LCLObject.BoundsRect;
|
|
if not IsWidgetOK then
|
|
exit;
|
|
if GetContainerWidget^.get_realized then
|
|
begin
|
|
GetContainerWidget^.get_allocation(@AAlloc);
|
|
Result := Rect(AAlloc.x, AAlloc.y, AAlloc.width + AAlloc.x,AAlloc.height + AAlloc.y);
|
|
end else
|
|
if FWidget^.get_realized then
|
|
begin
|
|
FWidget^.get_allocation(@AAlloc);
|
|
Result := Rect(AAlloc.x, AAlloc.y, AAlloc.width + AAlloc.x,AAlloc.height + AAlloc.y);
|
|
end;
|
|
Types.OffsetRect(Result, -Result.Left, -Result.Top);
|
|
end;
|
|
|
|
function TGtk3Widget.getClientBounds: TRect;
|
|
var
|
|
AAlloc: TGtkAllocation;
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
if IsWidgetOk then
|
|
begin
|
|
if FWidget^.get_realized then
|
|
begin
|
|
FWidget^.get_allocation(@AAlloc);
|
|
Result := Rect(AAlloc.x, AAlloc.y, AAlloc.width + AAlloc.x,AAlloc.height + AAlloc.y);
|
|
end else
|
|
if GetContainerWidget^.get_realized then
|
|
begin
|
|
GetContainerWidget^.get_allocation(@AAlloc);
|
|
Result := Rect(AAlloc.x, AAlloc.y, AAlloc.width + AAlloc.x,AAlloc.height + AAlloc.y);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetBounds(ALeft,ATop,AWidth,AHeight:integer);
|
|
var
|
|
ARect: TGdkRectangle;
|
|
Alloc: TGtkAllocation;
|
|
begin
|
|
if (Widget=nil) then
|
|
exit;
|
|
|
|
LCLWidth := AWidth;
|
|
LCLHeight := AHeight;
|
|
ARect.x := ALeft;
|
|
ARect.y := ATop;
|
|
ARect.width := AWidth;
|
|
ARect.Height := AHeight;
|
|
with Alloc do
|
|
begin
|
|
x := ALeft;
|
|
y := ATop;
|
|
width := AWidth;
|
|
height := AHeight;
|
|
end;
|
|
|
|
if Self is TGtk3Button then
|
|
begin
|
|
AWidth:=Max(1,AWidth-4);
|
|
AHeight:=Max(1,AHeight-4);
|
|
end;
|
|
|
|
BeginUpdate;
|
|
try
|
|
{fixes gtk3 assertion}
|
|
if not Widget^.get_realized then
|
|
Widget^.realize;
|
|
|
|
//this should be removed in future.
|
|
Widget^.set_size_request(AWidth,AHeight);
|
|
|
|
if Gtk3IsContainer(Widget) then // according to the gtk3 docs only GtkContainer should call this
|
|
Widget^.size_allocate(@ARect);
|
|
|
|
if Widget^.get_visible then
|
|
Widget^.set_allocation(@Alloc);
|
|
|
|
if LCLObject.Parent <> nil then
|
|
Move(ALeft, ATop);
|
|
|
|
// we must trigger get_preferred_width after changing size
|
|
Widget^.queue_resize;
|
|
|
|
{if wtProgressBar in WidgetType then
|
|
getContainerWidget^.set_size_request(AWidth, AHeight);}
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetLclFont(const AFont:TFont);
|
|
var
|
|
AGtkFont: PPangoFontDescription;
|
|
APangoStyle: TPangoStyle;
|
|
Family: String;
|
|
Stretch: TPangoStretch;
|
|
Weight: TPangoWeight;
|
|
begin
|
|
if not IsWidgetOk then exit;
|
|
if IsFontNameDefault(AFont.Name) then
|
|
begin
|
|
AGtkFont := Self.Font;
|
|
Stretch := PANGO_STRETCH_NORMAL;
|
|
Weight := PANGO_WEIGHT_NORMAL;
|
|
end else
|
|
begin
|
|
Family := AFont.Name;
|
|
ExtractPangoFontFaceSuffixes(Family, Stretch, Weight);
|
|
AGtkFont := TPangoFontDescription.new;
|
|
AGtkFont^.set_family(PgChar(Family));
|
|
end;
|
|
|
|
if Stretch <> PANGO_STRETCH_NORMAL then
|
|
AGtkFont^.set_stretch(Stretch);
|
|
|
|
if AFont.Size <> 0 then
|
|
AGtkFont^.set_size(Abs(AFont.Size) * PANGO_SCALE);
|
|
|
|
if (fsBold in AFont.Style) and (Weight < PANGO_WEIGHT_SEMIBOLD) then
|
|
// bold is specified by the fsBold flag only
|
|
AGtkFont^.set_weight(PANGO_WEIGHT_BOLD)
|
|
else if (Weight <> PANGO_WEIGHT_NORMAL) then
|
|
AGtkFont^.set_weight(Weight);
|
|
|
|
if fsItalic in AFont.Style then
|
|
APangoStyle := PANGO_STYLE_ITALIC
|
|
else
|
|
APangoStyle := PANGO_STYLE_NORMAL;
|
|
AGtkFont^.set_style(APangoStyle);
|
|
|
|
Font := AGtkFont;
|
|
FontColor := AFont.Color;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetWindowShape(AShape: PGdkPixBuf; AWindow: PGdkWindow);
|
|
var
|
|
imageSurface: Pcairo_surface_t;
|
|
ARegion: Pcairo_region_t;
|
|
ACairoRect: Tcairo_rectangle_int_t;
|
|
begin
|
|
if (AWindow = nil) or not Gtk3IsGdkWindow(AWindow) then
|
|
exit;
|
|
if AShape = nil then
|
|
begin
|
|
ACairoRect.x := 0;
|
|
ACairoRect.y := 0;
|
|
ACairoRect.width := AWindow^.get_width;
|
|
ACairoRect.height := AWindow^.get_height;
|
|
ARegion := cairo_region_create_rectangle(@ACairoRect);
|
|
gdk_window_shape_combine_region(AWindow, ARegion, 0, 0);
|
|
cairo_region_destroy(ARegion);
|
|
end else
|
|
begin
|
|
//TODO: check on scaled displays.
|
|
imageSurface := gdk_cairo_surface_create_from_pixbuf(AShape, 1, AWindow);
|
|
ARegion := gdk_cairo_region_create_from_surface(imageSurface);
|
|
gdk_window_shape_combine_region(AWindow, ARegion, 0, 0);
|
|
cairo_region_destroy(ARegion);
|
|
cairo_surface_destroy(imageSurface);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Widget.GetContainerWidget: PGtkWidget;
|
|
begin
|
|
if Assigned(FCentralWidget) then
|
|
Result := FCentralWidget
|
|
else
|
|
Result := FWidget;
|
|
end;
|
|
|
|
function TGtk3Widget.GetPosition(out APoint: TPoint): Boolean;
|
|
var
|
|
GdkWindow: PGdkWindow;
|
|
GtkLeft, GtkTop: GInt;
|
|
Alloc:TGtkAllocation;
|
|
prnt:TGtk3Widget;
|
|
wtype:TGType;
|
|
begin
|
|
fWidget^.get_allocation(@Alloc);
|
|
if (alloc.X=-1) and (alloc.Y=-1) and (alloc.height=1) and (alloc.width=1) then
|
|
// default allocation
|
|
else
|
|
begin
|
|
APoint.X:=alloc.X;
|
|
APoint.Y:=alloc.Y;
|
|
end;
|
|
|
|
prnt:=self.GetParent; // TGtk3Widget
|
|
if (prnt<>nil) then
|
|
begin
|
|
wtype:=prnt.getType; // parent widget type
|
|
if (wtype<>gtk_fixed_get_type()) and
|
|
(wtype<>gtk_layout_get_type()) then
|
|
begin
|
|
// widget is not on a normal client area. e.g. TPage
|
|
Apoint.X:=0;
|
|
APoint.Y:=0;
|
|
Result:=true;
|
|
end
|
|
else
|
|
if (wtype=gtk_fixed_get_type()) and
|
|
prnt.Widget^.get_has_window then
|
|
begin
|
|
// widget on a fixed, but fixed w/o window
|
|
prnt.Widget^.get_allocation(@alloc);
|
|
Dec(Apoint.X, alloc.x);
|
|
Dec(APoint.Y, alloc.y);
|
|
Result:=true;
|
|
end;
|
|
end;
|
|
|
|
if (self.getType=gtk_window_get_type()) then
|
|
begin
|
|
GdkWindow:=Self.Widget^.window;
|
|
if (GdkWindow<>nil) and (Self.FWidget^.get_mapped) then
|
|
begin
|
|
// window is mapped = window manager has put the window somewhere
|
|
gdk_window_get_root_origin(GdkWindow, @GtkLeft, @GtkTop);
|
|
APoint.X := GtkLeft;
|
|
APoint.Y := GtkTop;
|
|
Result:=true;
|
|
end else
|
|
begin
|
|
// the gtk has not yet put the window to the final position
|
|
// => the gtk/gdk position is not reliable
|
|
// => use the LCL coords
|
|
Apoint.X:=LCLObject.Left;
|
|
Apoint.Y:=LCLObject.Top;
|
|
Result:=true;
|
|
end;
|
|
//DebugLn(['TGtk3WidgetSet.GetWindowRelativePosition ',GetWidgetDebugReport(aWidget),' Left=',Left,' Top=',Top,' GdkWindow=',GdkWindow<>nil]);
|
|
end;
|
|
//DebugLn(['TGtk3WidgetSet.GetWindowRelativePosition ',GetWidgetDebugReport(aWidget),' Left=',Left,' Top=',Top]);
|
|
end;
|
|
|
|
procedure TGtk3Widget.Release;
|
|
begin
|
|
LCLObject := nil;
|
|
Free;
|
|
end;
|
|
|
|
procedure TGtk3Widget.Hide;
|
|
begin
|
|
if Assigned(FWidget) then
|
|
FWidget^.hide;
|
|
end;
|
|
|
|
function TGtk3Widget.getParent: TGtk3Widget;
|
|
begin
|
|
Result := Gtk3WidgetFromGtkWidget(Widget^.get_parent);
|
|
end;
|
|
|
|
function TGtk3Widget.GetWindow: PGdkWindow;
|
|
begin
|
|
Result := FWidget^.window;
|
|
end;
|
|
|
|
procedure TGtk3Widget.Move(ALeft, ATop: Integer);
|
|
var
|
|
AParent: TGtk3Widget;
|
|
XOffset, YOffset: Integer;
|
|
aWindow: PGdkWindow;
|
|
begin
|
|
AParent := getParent;
|
|
if (AParent <> nil) then
|
|
begin
|
|
XOffset := 0;
|
|
YOffset := 0;
|
|
if (wtContainer in AParent.WidgetType) then
|
|
PGtkFixed(AParent.GetContainerWidget)^.move(FWidget, ALeft, ATop)
|
|
else
|
|
if (wtLayout in AParent.WidgetType) then
|
|
begin
|
|
aWindow := PGtkLayout(AParent.GetContainerWidget)^.get_bin_window;
|
|
if Gtk3IsGdkWindow(aWindow) then
|
|
aWindow^.get_position(@XOffset, @YOffset);
|
|
PGtkLayout(AParent.GetContainerWidget)^.move(FWidget, ALeft - XOffset, ATop - YOffset);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.Activate;
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
if not FWidget^.visible then
|
|
exit;
|
|
if Gtk3IsGdkWindow(FWidget^.window) then
|
|
FWidget^.window^.raise_
|
|
else
|
|
begin
|
|
FWidget^.get_parent_window^.raise_;
|
|
end;
|
|
if FWidget^.can_focus then
|
|
FWidget^.grab_focus;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.preferredSize(var PreferredWidth,
|
|
PreferredHeight: integer; WithThemeSpace: Boolean);
|
|
var
|
|
AMinH: gint;
|
|
AMinW: gint;
|
|
AWidget:PGtkWidget;
|
|
{$IFDEF GTK3DEBUGPREFERREDSIZE}
|
|
ABorder: TGtkBorder;
|
|
{$ENDIF}
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
if [wtComboBox] * WidgetType <> [] then
|
|
AWidget := Widget
|
|
else
|
|
AWidget := getContainerWidget;
|
|
{$IFDEF GTK3DEBUGPREFERREDSIZE}
|
|
AWidget^.get_size_request(@AMinW, @AMinH);
|
|
DebugLn('>',dbgsName(LCLObject),'.preferredSize W=',dbgs(PreferredWidth),' H=',dbgs(PreferredHeight),' WithThemeSpace ',dbgs(WithThemeSpace),' AMinW=',dbgs(AMinW),' AMinH=',dbgs(AMinH));
|
|
{$ENDIF}
|
|
AWidget^.get_preferred_height(@AMinH, @PreferredHeight);
|
|
AWidget^.get_preferred_width(@AMinW, @PreferredWidth);
|
|
{$IFDEF GTK3DEBUGPREFERREDSIZE}
|
|
if WithThemeSpace then
|
|
begin
|
|
AWidget^.get_style_context^.get_margin(GTK_STATE_FLAG_NORMAL, @ABorder);
|
|
with ABorder do
|
|
DebugLn('BorderSpaces ',Format('L %d T %d R %d B %d',[Left, Top, Right, Bottom]));
|
|
AWidget^.get_style_context^.get_padding(GTK_STATE_FLAG_NORMAL, @ABorder);
|
|
with ABorder do
|
|
DebugLn('Padding ',Format('L %d T %d R %d B %d',[Left, Top, Right, Bottom]));
|
|
end;
|
|
DebugLn('<',dbgsName(LCLObject),'.preferredSize W=',dbgs(PreferredWidth),' H=',dbgs(PreferredHeight),' WithThemeSpace ',dbgs(WithThemeSpace),' AMinH=',dbgs(AMinH),' AMinW=',dbgs(AMinW));
|
|
{$ENDIF}
|
|
if [wtComboBox] * WidgetType <> [] then
|
|
begin
|
|
PreferredWidth := 0;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetCursor(ACursor: HCURSOR);
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
if GetContainerWidget^.get_has_window and Gtk3IsGdkWindow(GetContainerWidget^.window) then
|
|
SetWindowCursor(GetContainerWidget^.window, HCURSOR(TGtk3Cursor(ACursor).Handle), False, True)
|
|
else
|
|
if Widget^.get_has_window and Gtk3IsGdkWindow(Widget^.window) then
|
|
SetWindowCursor(Widget^.window, HCURSOR(TGtk3Cursor(ACursor).Handle), False, True)
|
|
else // fallback for window-less widgets
|
|
if Assigned(self.getParent) then
|
|
Self.getParent.SetCursor(ACursor);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetFocus;
|
|
begin
|
|
if GetContainerWidget^.can_focus then
|
|
GetContainerWidget^.grab_focus
|
|
else
|
|
if FWidget^.can_focus then
|
|
FWidget^.grab_focus;
|
|
end;
|
|
|
|
procedure TGtk3Widget.SetParent(AParent: TGtk3Widget; const ALeft, ATop: Integer
|
|
);
|
|
begin
|
|
if FWidget=nil then exit;;
|
|
if wtLayout in AParent.WidgetType then
|
|
PGtkLayout(AParent.GetContainerWidget)^.put(FWidget, ALeft, ATop)
|
|
else
|
|
if wtContainer in AParent.WidgetType then
|
|
PGtkFixed(AParent.GetContainerWidget)^.put(FWidget, ALeft, ATop)
|
|
else
|
|
if wtNotebook in AParent.WidgetType then
|
|
// do nothing !
|
|
else
|
|
FWidget^.set_parent(AParent.GetContainerWidget);
|
|
end;
|
|
|
|
procedure TGtk3Widget.Show;
|
|
begin
|
|
if IsValidHandle then
|
|
begin
|
|
FWidget^.show;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Widget.ShowAll;
|
|
begin
|
|
if IsValidHandle then
|
|
FWidget^.show_all;
|
|
end;
|
|
|
|
procedure TGtk3Widget.Update(ARect: PRect);
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
if (ARect <> nil) then
|
|
begin
|
|
if (aRect^.Width > 0) and (ARect^.Height > 0) then
|
|
begin
|
|
with ARect^ do
|
|
FWidget^.queue_draw_area(Left, Top, Right - Left, Bottom - Top);
|
|
if FWidget <> GetContainerWidget then
|
|
with ARect^ do
|
|
GetContainerWidget^.queue_draw_area(Left, Top, Right - Left, Bottom - Top);
|
|
end;
|
|
end else
|
|
begin
|
|
//FWidget^.queue_draw;
|
|
if FWidget <> GetContainerWidget then
|
|
GetContainerWidget^.queue_draw
|
|
else
|
|
FWidget^.queue_draw;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TGtk3StatusBar }
|
|
|
|
function TGtk3StatusBar.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
Result := TGtkEventBox.new;
|
|
FCentralWidget := TGtkHBox.new(GTK_ORIENTATION_HORIZONTAL, 1);
|
|
PGtkBox(FCentralWidget)^.set_homogeneous(True);
|
|
PGtkEventBox(Result)^.add(FCentralWidget);
|
|
//TODO: add routines to set panels
|
|
end;
|
|
|
|
{ TGtk3Panel }
|
|
|
|
procedure TGtk3Panel.SetBorderStyle(AValue: TBorderStyle);
|
|
begin
|
|
if FBorderStyle = AValue then Exit;
|
|
FBorderStyle := AValue;
|
|
PGtkLayout(Widget)^.set_border_width(Ord(AValue));
|
|
end;
|
|
|
|
function TGtk3Panel.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AGdkRGBA: TGdkRGBA;
|
|
begin
|
|
FHasPaint := True;
|
|
FBorderStyle := bsNone;
|
|
|
|
FWidgetType := [wtWidget, wtLayout, wtPanel];
|
|
Result := TGtkLayout.new(nil, nil);
|
|
Result^.set_has_window(True);
|
|
// as GtkFixed have no child control here - nobody triggers resizing
|
|
// GNOME takes care of it, but other WM - not
|
|
// this is here to make TGtk3Panel shown under Plasma
|
|
//Result^.set_size_request(LCLObject.Width,LCLObject.Height);
|
|
PGtkLayout(Result)^.set_size(1, 1);
|
|
|
|
// AColor := Result^.style^.bg[0];
|
|
// writeln('BG COLOR R=',AColor.red,' G=',AColor.green,' B=',AColor.blue);
|
|
// now we make panel completely transparent.
|
|
// SetColor must usr override_background_color for panel
|
|
// we must implement cairo_pattern_t since background can be brush
|
|
AGdkRGBA.alpha := 0;
|
|
AGdkRGBA.red := 0; // AColor.Red / 65535.00;
|
|
AGdkRGBA.blue := 0; // AColor.Blue / 65535.00;
|
|
AGdkRGBA.green := 0; // AColor.green / 65535.00;
|
|
Result^.override_background_color(GTK_STATE_FLAG_NORMAL, @AGdkRGBA);
|
|
Result^.override_background_color([GTK_STATE_FLAG_ACTIVE], @AGdkRGBA);
|
|
Result^.override_background_color([GTK_STATE_FLAG_FOCUSED], @AGdkRGBA);
|
|
Result^.override_background_color([GTK_STATE_FLAG_PRELIGHT], @AGdkRGBA);
|
|
Result^.override_background_color([GTK_STATE_FLAG_SELECTED], @AGdkRGBA);
|
|
Result^.show_all;
|
|
end;
|
|
|
|
procedure TGtk3Panel.DoBeforeLCLPaint;
|
|
var
|
|
DC: TGtk3DeviceContext;
|
|
NColor: TColor;
|
|
begin
|
|
inherited DoBeforeLCLPaint;
|
|
if not Visible then
|
|
exit;
|
|
DC := TGtk3DeviceContext(Context);
|
|
NColor := LCLObject.Color;
|
|
if (NColor <> clNone) and (NColor <> clDefault) then
|
|
begin
|
|
DC.CurrentBrush.Color := ColorToRGB(NColor);
|
|
DC.fillRect(0, 0, LCLObject.Width, LCLObject.Height);
|
|
end;
|
|
|
|
if BorderStyle <> bsNone then
|
|
begin
|
|
DC.CurrentPen.Color := ColorToRGB(clBtnShadow); // not sure what color to use here?
|
|
DC.drawRect(0, 0, LCLObject.Width, LCLObject.Height, False, True);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Panel.setText(const AValue: String);
|
|
begin
|
|
if FText = AValue then
|
|
exit;
|
|
FText := AValue;
|
|
if Self.Visible then
|
|
Widget^.queue_draw;
|
|
end;
|
|
|
|
{ TGtk3GroupBox }
|
|
|
|
function TGtk3GroupBox.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
FHasPaint := True;
|
|
FGroupBoxType := gbtGroupBox;
|
|
FWidgetType := [wtWidget, wtLayout, wtGroupBox];
|
|
Result := LCLGtkFrameNew;
|
|
FCentralWidget := TGtkLayout.new(nil, nil);
|
|
PGtkBin(Result)^.add(FCentralWidget);
|
|
FCentralWidget^.set_has_window(True);
|
|
PGtkFrame(result)^.set_label_align(0.1,0.5);
|
|
PGtkLayout(FCentralWidget)^.set_size(1, 1);
|
|
Result^.show_all;
|
|
end;
|
|
|
|
function TGtk3GroupBox.getText: String;
|
|
begin
|
|
Result := '';
|
|
if IsWidgetOK then
|
|
begin
|
|
if PGtkFrame(Widget)^.get_label_widget = nil then
|
|
exit;
|
|
Result := {%H-}ReplaceUnderscoresWithAmpersands(PGtkFrame(Widget)^.get_label);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3GroupBox.setText(const AValue: String);
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
if AValue = '' then
|
|
PGtkFrame(Widget)^.set_label_widget(nil)
|
|
else
|
|
begin
|
|
if PGtkFrame(Widget)^.get_label_widget = nil then
|
|
PGtkFrame(Widget)^.set_label_widget(TGtkLabel.new(''));
|
|
{%H-}PGtkFrame(Widget)^.set_label(PgChar({%H-}ReplaceAmpersandsWithUnderscores(AValue)));
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{$IF DEFINED(GTK3DEBUGSIZE) OR DEFINED(GTK3DEBUGGROUPBOX)}
|
|
procedure ContainerChildrenCallback(widget: PGtkWidget; data: gpointer); cdecl;
|
|
begin
|
|
// This callback is called for each child of the GtkFixed container
|
|
WriteLn('TGtk3GroupBox Child widget pointer: ', PtrUInt(widget),' ACtl=',dbgsName(TGtk3WIdget(data)));
|
|
|
|
// Example: Print the widget type name
|
|
WriteLn('TGtk3GroupBox Widget type: ', gtk_widget_get_name(widget));
|
|
end;
|
|
{$ENDIF}
|
|
|
|
class procedure TGtk3GroupBox.GroupBoxSizeAllocate(AWidget:PGtkWidget;AGdkRect:
|
|
PGdkRectangle;Data:gpointer);cdecl;
|
|
var
|
|
Msg: TLMSize;
|
|
NewSize: TSize;
|
|
ACtl: TGtk3GroupBox;
|
|
AState: TGdkWindowState;
|
|
Alloc: TGtkAllocation;
|
|
AList:PGList;
|
|
AFixed: PGtkFixed;
|
|
i:Integer;
|
|
begin
|
|
if AWidget=nil then ;
|
|
|
|
ACtl := TGtk3GroupBox(Data);
|
|
|
|
{$IF DEFINED(GTK3DEBUGSIZE) OR DEFINED(GTK3DEBUGGROUPBOX)}
|
|
with AGdkRect^ do
|
|
DebugLn('**** GroupBoxSizeAllocate **** ....',dbgsName(ACtl.LCLObject),
|
|
' ',Format('GTK x %d y %d w %d h %d',[x, y, width, height]),
|
|
Format(' LCL W=%d H=%d LLW %d LLH %d upd=%s',[ACtl.LCLObject.Width, ACtl.LCLObject.Height, ACtl.LCLWidth, ACtl.LCLHeight, BoolToStr(ACtl.InUpdate, True)]));
|
|
{$ENDIF}
|
|
|
|
with Alloc do
|
|
begin
|
|
x := AGdkRect^.x;
|
|
y := AGdkRect^.y;
|
|
Width := AGdkRect^.width;
|
|
Height := AGdkRect^.height;
|
|
end;
|
|
|
|
gtk_widget_set_clip(AWidget, @Alloc);
|
|
|
|
if not Assigned(ACtl.LCLObject) then exit;
|
|
|
|
// return size w/o frame
|
|
NewSize.cx := AGdkRect^.width;
|
|
NewSize.cy := AGdkRect^.height;
|
|
|
|
if not (csDesigning in ACtl.LCLObject.ComponentState) then
|
|
begin
|
|
if ACtl.InUpdate then
|
|
exit;
|
|
end;
|
|
|
|
{$IF DEFINED(GTK3DEBUGSIZE) OR DEFINED(GTK3DEBUGGROUPBOX)}
|
|
if not ACtl.LCLObject.AutoSize and (ACtl.LCLWidth > 0) and (ACtl.LCLHeight > 0) and
|
|
ACtl.LCLObject.ClientRectNeedsInterfaceUpdate then
|
|
begin
|
|
if (AGdkRect^.Width = ACtl.LCLWidth) and (AGdkRect^.Height = ACtl.LCLHeight) then
|
|
begin
|
|
//ACtl.LCLObject.DoAdjustClientRectChange;
|
|
AFixed := PGtkFixed(ACtl.getContainerWidget);
|
|
if AFixed^.compute_expand(GTK_ORIENTATION_VERTICAL) then
|
|
AFixed^.resize_children;
|
|
// PGtkLayout(AFixed)^.set_size(AFixed^.get_allocated_width, AFixed^.get_allocated_height);
|
|
gtk_container_foreach(AFixed, @ContainerChildrenCallback, ACtl);
|
|
exit;
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
if ACtl.LCLObject.ClientRectNeedsInterfaceUpdate then
|
|
ACtl.LCLObject.DoAdjustClientRectChange;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_SIZE;
|
|
Msg.SizeType := SIZE_RESTORED;
|
|
|
|
Msg.SizeType := Msg.SizeType or Size_SourceIsInterface;
|
|
|
|
Msg.Width := Word(NewSize.cx);
|
|
Msg.Height := Word(NewSize.cy);
|
|
ACtl.DeliverMessage(Msg);
|
|
end;
|
|
|
|
{This routine is used as long as gtk3 is beta and getClientRect needs debugging}
|
|
function TGtk3GroupBox.GetInnerClientRect(Frame: PGtkWidget): TRect;
|
|
var
|
|
Allocation: TGdkRectangle;
|
|
AStyleContext: PGtkStyleContext;
|
|
Padding, Border: TGtkBorder;
|
|
LabelWidget: PGtkWidget;
|
|
FinalRect: TGdkRectangle;
|
|
minH:gint;
|
|
natH:gint;
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
|
|
gtk_widget_get_allocation(Frame, @Allocation);
|
|
LabelWidget := gtk_frame_get_label_widget(PGtkFrame(Frame));
|
|
|
|
AStyleContext := gtk_widget_get_style_context(Frame);
|
|
gtk_style_context_get_padding(AStyleContext, GTK_STATE_FLAG_NORMAL, @Padding);
|
|
gtk_style_context_get_border(AStyleContext, GTK_STATE_FLAG_NORMAL, @Border);
|
|
|
|
FinalRect.X := Allocation.X + Border.Left + Padding.Left;
|
|
FinalRect.Y := Allocation.Y + Border.Top + Padding.Top;
|
|
FinalRect.Width := Allocation.Width - Border.Left - Border.Right - Padding.Left - Padding.Right;
|
|
FinalRect.Height := Allocation.Height - Border.Top - Border.Bottom - Padding.Top - Padding.Bottom;
|
|
|
|
if PGtkFrame(Frame)^.get_shadow_type > GTK_SHADOW_NONE then
|
|
begin
|
|
// this looks like a bug in gtk3, that's why I separated this part of code. Zeljan.
|
|
if (Border.left = 0) and (Border.Right = 0) then
|
|
dec(FinalRect.Width, 2);
|
|
if (Border.Top = 0) and (Border.Bottom = 0) then
|
|
dec(FinalRect.Height, 2);
|
|
end;
|
|
|
|
if Assigned(LabelWidget) then
|
|
begin
|
|
PGtkLabel(LabelWidget)^.get_preferred_height(@minH, @natH);
|
|
FinalRect.Y := FinalRect.Y + natH;
|
|
FinalRect.Height := FinalRect.Height - natH;
|
|
{$IF DEFINED(GTK3DEBUGSIZE) OR DEFINED(GTK3DEBUGGROUPBOX)}
|
|
writeln('LabelAllocation LCLObject.Caption=',LCLObject.Caption,' LabelText=',PGtkLabel(LabelWidget)^.get_text,' MinH=',MinH,' NatH=',NatH);
|
|
{$ENDIF}
|
|
end;
|
|
|
|
Result := RectFromGdkRect(FinalRect);
|
|
end;
|
|
|
|
procedure TGtk3GroupBox.DoBeforeLCLPaint;
|
|
var
|
|
DC: TGtk3DeviceContext;
|
|
NColor: TColor;
|
|
begin
|
|
inherited DoBeforeLCLPaint;
|
|
if not Visible then
|
|
exit;
|
|
DC := TGtk3DeviceContext(Context);
|
|
NColor := LCLObject.Color;
|
|
if (NColor <> clNone) and (NColor <> clDefault) then
|
|
begin
|
|
DC.CurrentBrush.Color := ColorToRGB(NColor);
|
|
DC.fillRect(0, 0, getContainerWidget^.get_allocated_width, getContainerWidget^.get_allocated_height);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3GroupBox.ConnectSizeAllocateSignal(ToWidget:PGtkWidget);
|
|
begin
|
|
g_signal_connect_data(ToWidget,'size-allocate',TGCallback(@GroupBoxSizeAllocate), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
|
|
function TGtk3GroupBox.getClientRect:TRect;
|
|
var
|
|
Alloc:TGtkAllocation;
|
|
R: TRect;
|
|
begin
|
|
Result := GetInnerClientRect(Widget);
|
|
Types.OffsetRect(Result, -Result.Left, -Result.Top);
|
|
end;
|
|
|
|
{ TGtk3Editable }
|
|
|
|
function gtk3EditableDelayedSelStart(AData: Pointer): gboolean; cdecl;
|
|
var
|
|
AWidget: PGtkEditable;
|
|
AEditable: TGtk3Editable;
|
|
begin
|
|
Result := False;
|
|
AEditable := TGtk3Editable(AData);
|
|
AWidget := PGtkEditable(TGtk3Widget(AData).Widget);
|
|
if (AEditable.PrivateCursorPos <> -1) and (AEditable.PrivateSelection <> -1) then
|
|
begin
|
|
gtk_editable_select_region(AWidget,AEditable.PrivateCursorPos, AEditable.PrivateSelection);
|
|
// gtk_editable_set_position(AWidget, TGtk3Editable(AData).PrivateCursorPos);
|
|
end;
|
|
AEditable.PrivateCursorPos := -1;
|
|
AEditable.PrivateSelection := -1;
|
|
g_idle_remove_by_data(AData);
|
|
end;
|
|
|
|
function TGtk3Editable.GetReadOnly: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOK then
|
|
Result := not PGtkEditable(Widget)^.get_editable;
|
|
end;
|
|
|
|
procedure TGtk3Editable.SetReadOnly(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkEditable(Widget)^.set_editable(not AValue);
|
|
end;
|
|
|
|
function TGtk3Editable.getCaretPos: TPoint;
|
|
begin
|
|
Result := Point(0, 0);
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result.X := PGtkEditable(Widget)^.get_position;
|
|
end;
|
|
|
|
procedure TGtk3Editable.SetCaretPos(AValue: TPoint);
|
|
begin
|
|
if not IsWidgetOk then
|
|
exit;
|
|
PGtkEditable(Widget)^.set_position(AValue.X);
|
|
end;
|
|
|
|
function TGtk3Editable.getSelStart: Integer;
|
|
var
|
|
AStart: gint;
|
|
AStop: gint;
|
|
begin
|
|
Result := 0;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
if PGtkEditable(Widget)^.get_selection_bounds(@AStart, @AStop) then
|
|
begin
|
|
Result := AStart;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Editable.getSelLength: Integer;
|
|
var
|
|
AStart: gint;
|
|
AStop: gint;
|
|
begin
|
|
Result := 0;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
if PGtkEditable(Widget)^.get_selection_bounds(@AStart, @AStop) then
|
|
begin
|
|
Result := AStop - AStart;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Editable.setSelStart(AValue: Integer);
|
|
var
|
|
ASelStart:gint;
|
|
ASelStop:gint;
|
|
begin
|
|
if not IsWidgetOk then
|
|
exit;
|
|
CaretPos := Point(AValue, 0);
|
|
PGtkEditable(FWidget)^.get_selection_bounds(@ASelStart, @ASelStop);
|
|
if ASelStop < AValue then
|
|
ASelStop := AValue;
|
|
|
|
if InUpdate then
|
|
begin
|
|
PrivateCursorPos := ASelStart;
|
|
PrivateSelection := AValue;
|
|
end;
|
|
|
|
PGtkEditable(FWidget)^.select_region(AValue, ASelStop);
|
|
end;
|
|
|
|
procedure TGtk3Editable.setSelLength(AValue: Integer);
|
|
var
|
|
AStart: gint;
|
|
AStop: gint;
|
|
begin
|
|
if not IsWidgetOk then
|
|
exit;
|
|
PGtkEditable(Widget)^.get_selection_bounds(@AStart, @AStop);
|
|
AStart := CaretPos.X;
|
|
// DebugLn('TGtk3Editable.SetSelLength ',dbgsName(LCLObject),' value=',dbgs(AValue),' AStart=',dbgs(AStart),' InUpdate ',dbgs(InUpdate));
|
|
if InUpdate then
|
|
begin
|
|
PrivateCursorPos := AStart;
|
|
PrivateSelection := AValue;
|
|
// g_idle_add(@gtk3EditableDelayedSelStart, Self)
|
|
// setDelayed later
|
|
PGtkEditable(Widget)^.select_region(AStart, AStart + AValue)
|
|
end else
|
|
PGtkEditable(Widget)^.select_region(AStart, AStart + AValue);
|
|
end;
|
|
|
|
{ TGtk3Entry }
|
|
|
|
function TGtk3Entry.GetAlignment: TAlignment;
|
|
var
|
|
AFloat: GFloat;
|
|
begin
|
|
Result := taLeftJustify;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
AFloat := PGtkEntry(Widget)^.get_alignment;
|
|
if AFloat = 1 then
|
|
Result := taRightJustify
|
|
else
|
|
if AFloat = 0.5 then
|
|
Result := taCenter;
|
|
end;
|
|
|
|
procedure TGtk3Entry.SetAlignment(AValue: TAlignment);
|
|
var
|
|
AFloat: GFloat;
|
|
begin
|
|
if not IsWidgetOk then
|
|
exit;
|
|
case AValue of
|
|
taCenter: AFloat := 0.5;
|
|
taRightJustify: AFloat := 1.0;
|
|
else
|
|
AFloat := 0;;
|
|
end;
|
|
PGtkEntry(Widget)^.set_alignment(AFloat);
|
|
end;
|
|
|
|
function TGtk3Entry.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := AKey in [VK_UP, VK_DOWN];
|
|
end;
|
|
|
|
class procedure TGtk3Entry.EntryChanged({%H-}AEntry: PGtkEntryBuffer; AData: GPointer); cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
S:String;
|
|
I:Integer;
|
|
ASpin: TGtk3SpinEdit;
|
|
fl: double;
|
|
begin
|
|
FillChar(Msg{%H-}, SizeOf(Msg), 0);
|
|
Msg.Msg := CM_TEXTCHANGED;
|
|
if [wtSpinEdit] * TGtk3Widget(AData).WidgetType <> [] then
|
|
begin
|
|
ASpin := TGtk3SpinEdit(AData);
|
|
if not TGtk3Widget(AData).InUpdate then
|
|
begin
|
|
S := TGtk3SpinEdit(adata).getText;
|
|
I := 0;
|
|
if (ASpin.NumDigits = 0) then
|
|
begin
|
|
if TryStrToInt(S, I) then
|
|
begin
|
|
if (I >= Round(TGtk3SpinEdit(adata).Minimum)) and (I<= Round(TGtk3SpinEdit(adata).Maximum)) then
|
|
PGtkSpinButton(TGtk3SpinEdit(adata).Widget)^.set_value(I);
|
|
end;
|
|
end else
|
|
begin
|
|
fl := 0;
|
|
if TryStrToFloat(S, fl) then
|
|
begin
|
|
if (fl >= TGtk3SpinEdit(adata).Minimum) and (fl<= TGtk3SpinEdit(adata).Maximum) then
|
|
PGtkSpinButton(TGtk3SpinEdit(adata).Widget)^.set_value(fl);
|
|
end;
|
|
end;
|
|
end;
|
|
exit; // value-changed should trigger
|
|
end;
|
|
if not TGtk3Widget(AData).InUpdate then
|
|
TGtk3Widget(AData).DeliverMessage(Msg);
|
|
end;
|
|
|
|
class procedure TGtk3Entry.InsertText(editable: PGtkEditable; aNewText: PgChar; anewtextlen: gint;
|
|
var pos:Pgint; data: gpointer);cdecl;
|
|
var
|
|
i:integer;
|
|
edt:TGtk3Entry;
|
|
//s: string;
|
|
begin
|
|
if not Assigned(data) then
|
|
exit;
|
|
|
|
edt := TGtk3Entry(data);
|
|
if [wtSpinEdit] * TGtk3Widget(data).WidgetType <> [] then
|
|
begin
|
|
(*
|
|
if pos <> nil then
|
|
s := pos^.ToString
|
|
else
|
|
s := 'nil';
|
|
writeln('SpinEdit.InsertText text=',edt.getText,' newText="',aNewText,'"',' newLen=',anewTextLen,' pos=',s);
|
|
*)
|
|
end else
|
|
if (edt.LCLObject as TCustomEdit).NumbersOnly then
|
|
begin
|
|
for i := 0 to anewtextlen-1 do
|
|
begin
|
|
if not (aNewText[i] in ['0'..'9']) then
|
|
begin
|
|
g_signal_stop_emission_by_name(PGObject(editable), 'insert-text');
|
|
exit;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
class procedure TGtk3Entry.EntrySizeAllocate(AWidget:PGtkWidget;AGdkRect:
|
|
PGdkRectangle;Data:gpointer);cdecl;
|
|
var
|
|
Msg: TLMSize;
|
|
NewSize: TSize;
|
|
ACtl: TGtk3Entry;
|
|
AState: TGdkWindowState;
|
|
Alloc: TGtkAllocation;
|
|
begin
|
|
if AWidget=nil then ;
|
|
|
|
ACtl := TGtk3Entry(Data);
|
|
|
|
{$IF DEFINED(GTK3DEBUGENTRY) OR DEFINED(GTK3DEBUGENTRY)}
|
|
with AGdkRect^ do
|
|
DebugLn('**** EntrySizeAllocate **** ....',dbgsName(ACtl.LCLObject),
|
|
' ',Format('GTK x %d y %d w %d h %d',[x, y, width, height]),
|
|
Format(' LCL W=%d H=%d LLW %d LLH %d',[ACtl.LCLObject.Width, ACtl.LCLObject.Height, ACtl.LCLWidth, ACtl.LCLHeight]));
|
|
{$ENDIF}
|
|
|
|
with Alloc do
|
|
begin
|
|
x := AGdkRect^.x;
|
|
y := AGdkRect^.y;
|
|
Width := AGdkRect^.width;
|
|
Height := AGdkRect^.height;
|
|
end;
|
|
|
|
//fix layout, especially for GtkSpinButton
|
|
if [wtSpinEdit] * ACtl.WidgetType <> [] then
|
|
gtk_widget_set_clip(AWidget, @Alloc);
|
|
|
|
if not Assigned(ACtl.LCLObject) then exit;
|
|
|
|
// return size w/o frame
|
|
NewSize.cx := AGdkRect^.width;
|
|
NewSize.cy := AGdkRect^.height;
|
|
|
|
|
|
if not (csDesigning in ACtl.LCLObject.ComponentState) then
|
|
begin
|
|
if ACtl.InUpdate then
|
|
exit;
|
|
end;
|
|
|
|
if ((NewSize.cx <> ACtl.LCLObject.Width) or (NewSize.cy <> ACtl.LCLObject.Height) or
|
|
ACtl.LCLObject.ClientRectNeedsInterfaceUpdate) then
|
|
begin
|
|
ACtl.LCLObject.DoAdjustClientRectChange;
|
|
end;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_SIZE;
|
|
Msg.SizeType := SIZE_RESTORED;
|
|
|
|
Msg.SizeType := Msg.SizeType or Size_SourceIsInterface;
|
|
|
|
Msg.Width := Word(NewSize.cx);
|
|
Msg.Height := Word(NewSize.cy);
|
|
ACtl.DeliverMessage(Msg);
|
|
end;
|
|
|
|
procedure TGtk3Entry.ConnectSizeAllocateSignal(ToWidget:PGtkWidget);
|
|
begin
|
|
g_signal_connect_data(ToWidget,'size-allocate',TGCallback(@EntrySizeAllocate), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
function TGtk3Entry.getText: String;
|
|
begin
|
|
if IsValidHandle and IsWidgetOk then
|
|
Result := StrPas(PGtkEntry(Widget)^.get_text)
|
|
else
|
|
Result := '';
|
|
end;
|
|
|
|
procedure TGtk3Entry.setText(const AValue: String);
|
|
begin
|
|
if IsValidHandle and IsWidgetOK then
|
|
{%H-}PGtkEntry(Widget)^.set_text(PgChar(AValue));
|
|
end;
|
|
|
|
function TGtk3Entry.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
Result := LCLGtkEntryNew;
|
|
FWidgetType := FWidgetType + [wtEntry];
|
|
fText:=Params.Caption;
|
|
PrivateCursorPos := -1;
|
|
PrivateSelection := -1;
|
|
end;
|
|
|
|
procedure TGtk3Entry.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
|
|
Widget^.set_size_request(fParams.Width,fParams.Height);
|
|
PgtkEntry(Widget)^.set_text(PgChar(fParams.Caption));
|
|
|
|
Self.SetTextHint(TCustomEdit(Self.LCLObject).TextHint);
|
|
Self.SetNumbersOnly(TCustomEdit(Self.LCLObject).NumbersOnly);
|
|
|
|
g_signal_connect_data(Widget, 'changed', TGCallback(@EntryChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(Widget, 'insert-text', TGCallback(@InsertText), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
procedure TGtk3Entry.preferredSize(var PreferredWidth,PreferredHeight:integer;
|
|
WithThemeSpace:Boolean);
|
|
begin
|
|
inherited preferredSize(PreferredWidth,PreferredHeight,WithThemeSpace);
|
|
PreferredWidth := 0;
|
|
end;
|
|
|
|
procedure TGtk3Entry.SetPasswordChar(APasswordChar: Char);
|
|
var
|
|
PWChar: Integer;
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
PWChar := ord(APasswordChar);
|
|
if (PWChar < 192) or (PWChar = ord('*')) then
|
|
PWChar := 9679;
|
|
PGtkEntry(Widget)^.set_invisible_char(PWChar);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Entry.SetNumbersOnly(ANumbersOnly:boolean);
|
|
const
|
|
ips:array[boolean]of TGtkInputPurpose=(GTK_INPUT_PURPOSE_FREE_FORM,GTK_INPUT_PURPOSE_NUMBER);
|
|
begin
|
|
// this is not enough for numeric input - it is just a hint for GUI
|
|
if IsWidgetOK then
|
|
PGtkEntry(Widget)^.set_input_purpose(ips[ANumbersOnly]);
|
|
end;
|
|
|
|
procedure TGtk3Entry.SetTextHint(const AHint: string);
|
|
begin
|
|
if IsWidgetOK and (Ahint<>'') then
|
|
PGtkEntry(Widget)^.set_placeholder_text(PgChar(AHint));
|
|
end;
|
|
|
|
procedure TGtk3Entry.SetFrame(const aborder: boolean);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkEntry(Widget)^.set_has_frame(aborder);
|
|
end;
|
|
|
|
procedure TGtk3Entry.SetSelText(const ASelText: string);
|
|
var
|
|
AEntry: PGtkEntry;
|
|
AText: Pgchar;
|
|
APos: SizeInt;
|
|
begin
|
|
if not IsWidgetOK then
|
|
exit;
|
|
AEntry := PGtkEntry(Widget);
|
|
AText := AEntry^.get_text;
|
|
if AText = nil then
|
|
exit;
|
|
APos := Pos(aSelText, StrPas(AText));
|
|
if APos > 0 then
|
|
PGtkEditable(AEntry)^.select_region(APos - 1, APos - 1 + length(ASelText));
|
|
end;
|
|
|
|
function TGtk3Entry.GetTextHint:string;
|
|
|
|
begin
|
|
if IsWidgetOK then
|
|
Result:=PGtkEntry(Widget)^.get_placeholder_text()
|
|
else
|
|
Result:='';
|
|
end;
|
|
|
|
procedure TGtk3Entry.SetEchoMode(AVisible: Boolean);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkEntry(Widget)^.set_visibility(AVisible);
|
|
end;
|
|
|
|
procedure TGtk3Entry.SetMaxLength(AMaxLength: Integer);
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
PGtkEntry(Widget)^.set_max_length(AMaxLength);
|
|
PGtkEntry(Widget)^.set_width_chars(AMaxLength);
|
|
end;
|
|
|
|
end;
|
|
|
|
function TGtk3Entry.IsWidgetOk: Boolean;
|
|
begin
|
|
Result := (Widget <> nil) and Gtk3IsEntry(Widget);
|
|
end;
|
|
|
|
{ TGtk3SpinEdit }
|
|
|
|
function TGtk3SpinEdit.GetMaximum: Double;
|
|
var
|
|
AFloat: gdouble;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOk then
|
|
PGtkSpinButton(Widget)^.get_range(@AFloat ,@Result);
|
|
end;
|
|
|
|
function TGtk3SpinEdit.GetMinimum: Double;
|
|
var
|
|
AFloat: gdouble;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOk then
|
|
PGtkSpinButton(Widget)^.get_range(@Result ,@AFloat);
|
|
end;
|
|
|
|
function TGtk3SpinEdit.GetNumDigits: Integer;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOk then
|
|
Result := Integer(PGtkSpinButton(Widget)^.get_digits);
|
|
end;
|
|
|
|
function TGtk3SpinEdit.GetNumeric: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOk then
|
|
Result := PGtkSpinButton(Widget)^.get_numeric;
|
|
end;
|
|
|
|
function TGtk3SpinEdit.GetStep: Double;
|
|
var
|
|
AFloat: Double;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOk then
|
|
PGtkSpinButton(Widget)^.get_increments(@Result, @AFloat);
|
|
end;
|
|
|
|
function TGtk3SpinEdit.GetValue: Double;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOk then
|
|
Result := PGtkSpinButton(Widget)^.get_value;
|
|
end;
|
|
|
|
procedure TGtk3SpinEdit.SetNumDigits(AValue: Integer);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkSpinButton(Widget)^.set_digits(GUint(AValue));
|
|
end;
|
|
|
|
procedure TGtk3SpinEdit.SetNumeric(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkSpinButton(Widget)^.set_numeric(AValue);
|
|
end;
|
|
|
|
procedure TGtk3SpinEdit.SetStep(AValue: Double);
|
|
var
|
|
AStep: gdouble;
|
|
APage: gdouble;
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
PGtkSpinButton(Widget)^.get_increments(@AStep, @APage);
|
|
PGtkSpinButton(Widget)^.set_increments(AValue, APage);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3SpinEdit.SetValue(AValue: Double);
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
PGtkSpinButton(Widget)^.set_value(AValue);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3SpinEdit.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
ASpin: TCustomSpinEdit;
|
|
begin
|
|
PrivateCursorPos := -1;
|
|
PrivateSelection := -1;
|
|
ASpin := TCustomSpinEdit(LCLObject);
|
|
FWidgetType := FWidgetType + [wtSpinEdit];
|
|
Result := LCLGtkSpinButtonNew;
|
|
PGtkSpinButton(Result)^.set_range(ASpin.MinValue, ASpin.MaxValue);
|
|
PGtkSpinButton(Result)^.set_increments(ASpin.Increment, ASpin.Increment * 10); //page param gtk default is 10 * step.
|
|
end;
|
|
|
|
function TGtk3SpinEdit.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
class procedure TGtk3SpinEdit.SpinValueChanged(aSpin:PGtkSpinButton;aData:
|
|
gpointer);cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
FillChar(Msg{%H-}, SizeOf(Msg), 0);
|
|
Msg.Msg := CM_TEXTCHANGED;
|
|
if not TGtk3Widget(AData).InUpdate then
|
|
TGtk3Widget(AData).DeliverMessage(Msg);
|
|
end;
|
|
|
|
procedure TGtk3SpinEdit.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
g_signal_connect_data(Widget, 'value-changed', TGCallback(@SpinValueChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
function TGtk3SpinEdit.IsWidgetOk: Boolean;
|
|
begin
|
|
Result := (Widget <> nil) and Gtk3IsSpinButton(Widget);
|
|
end;
|
|
|
|
procedure TGtk3SpinEdit.SetRange(AMin, AMax: Double);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkSpinButton(Widget)^.set_range(AMin, AMax);
|
|
end;
|
|
|
|
{ TGtk3Range }
|
|
|
|
class procedure TGtk3Range.RangeChanged({%H-}ARange: PGtkRange; AData: gPointer); cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
if AData <> nil then
|
|
begin
|
|
if TGtk3Widget(AData).InUpdate then
|
|
Exit;
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
Msg.Msg := LM_CHANGED;
|
|
TGtk3Widget(AData).DeliverMessage(Msg);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Range.GetPosition: Integer;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOK then
|
|
Result := Round(PGtkRange(Widget)^.get_value);
|
|
end;
|
|
|
|
function TGtk3Range.GetRange: TPoint;
|
|
begin
|
|
Result := Point(0, 0);
|
|
if IsWidgetOK then
|
|
PGtkRange(Widget)^.get_slider_range(@Result.X, @Result.Y);
|
|
end;
|
|
|
|
procedure TGtk3Range.SetPosition(AValue: Integer);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkRange(Widget)^.set_value(gDouble(AValue));
|
|
end;
|
|
|
|
procedure TGtk3Range.SetRange(AValue: TPoint);
|
|
var
|
|
dx,dy: gdouble;
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
dx := AValue.X;
|
|
dy := AValue.Y;
|
|
PGtkRange(Widget)^.set_range(dx, dy);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Range.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
g_signal_connect_data(GetContainerWidget, 'value-changed', TGCallback(@RangeChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
procedure TGtk3Range.SetStep(AStep: Integer; APageSize: Integer);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkRange(Widget)^.set_increments(gDouble(AStep), gDouble(APageSize));
|
|
end;
|
|
|
|
{ TGtk3TrackBar }
|
|
|
|
function TGtk3TrackBar.GetReversed: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOK then
|
|
Result := PGtkScale(Widget)^.get_inverted;
|
|
end;
|
|
|
|
procedure TGtk3TrackBar.SetReversed(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkScale(Widget)^.set_inverted(AValue);
|
|
end;
|
|
|
|
function TGtk3TrackBar.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
ATrack: TCustomTrackBar;
|
|
begin
|
|
ATrack := TCustomTrackBar(LCLObject);
|
|
FWidgetType := FWidgetType + [wtTrackBar];
|
|
|
|
{ Result := TGtkHBox.new(1,0);
|
|
fCentralWidget:=PGtkWidget(TGtkScale.new(Ord(ATrack.Orientation), nil));
|
|
PgtkBox(Result)^.add(fCentralWidget);}
|
|
|
|
Result :=PGtkWidget(TGtkScale.new(TGtkOrientation(ATrack.Orientation), nil));
|
|
|
|
FOrientation := ATrack.Orientation;
|
|
if ATrack.Reversed then
|
|
PGtkScale(Result)^.set_inverted(True);
|
|
PGtkScale(Result)^.set_digits(0);
|
|
end;
|
|
|
|
procedure TGtk3TrackBar.SetBounds(ALeft, ATop, AWidth, AHeight: integer);
|
|
begin
|
|
Widget^.set_size_request(AWidth,AHeight);
|
|
inherited SetBounds(ALeft, ATop, AWidth, AHeight);
|
|
end;
|
|
|
|
function TGtk3TrackBar.GetTrackBarOrientation: TTrackBarOrientation;
|
|
begin
|
|
Result := FOrientation;
|
|
end;
|
|
|
|
procedure TGtk3TrackBar.SetScalePos(AValue: TTrackBarScalePos);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkScale(Widget)^.set_value_pos(TGtkPositionType(AValue));
|
|
end;
|
|
|
|
procedure TGtk3TrackBar.SetTickMarks(AValue: TTickMark; ATickStyle: TTickStyle);
|
|
var
|
|
i,cnt,fldw: Integer;
|
|
Track:TCustomTrackbar;
|
|
const
|
|
tick_map:array[TTrackBarOrientation,0..1] of TGtkPositionType =
|
|
((GTK_POS_TOP,GTK_POS_BOTTOM), // trHorizontal
|
|
(GTK_POS_LEFT,GTK_POS_RIGHT) // trVertical
|
|
);
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
PGtkScale(Widget)^.set_draw_value(ATickStyle <> tsNone);
|
|
if ATickStyle = tsNone then
|
|
PGtkScale(Widget)^.clear_marks
|
|
else
|
|
begin
|
|
PGtkScale(Widget)^.clear_marks;
|
|
Track:=TCustomTrackbar(LCLObject);
|
|
cnt:=round(abs(Track.max-Track.min)/Track.LineSize);
|
|
// highly-dense marks just enlarge GtkScale automatically
|
|
// it is up to user concent to do this
|
|
if Track.Orientation=trHorizontal then
|
|
fldw:=Track.Width
|
|
else
|
|
fldw:=Track.Height;
|
|
if cnt*Track.LineSize<fldw then
|
|
for i := Track.Min to Track.Max do
|
|
begin
|
|
if AValue in [tmBoth, tmTopLeft] then
|
|
PGtkScale(Widget)^.add_mark(gDouble(i), tick_map[Track.Orientation,0], nil);
|
|
if AValue in [tmBoth, tmBottomRight] then
|
|
PGtkScale(Widget)^.add_mark(gDouble(i), tick_map[Track.Orientation,1], nil);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TGtk3ScrollBar }
|
|
class procedure TGtk3ScrollBar.ScrollBarValueChanged(adjustment:PGtkAdjustment;data:
|
|
gpointer);cdecl;
|
|
var
|
|
scr: TScrollBar;
|
|
begin
|
|
scr := TScrollbar(TGtk3Widget(data).LCLObject);
|
|
{$note this must be fixed. Do not call LCL directly from here but send proper messages}
|
|
scr.SetParams(
|
|
round(adjustment^.value),
|
|
round(adjustment^.lower),
|
|
round(adjustment^.upper),
|
|
round(adjustment^.page_size));
|
|
end;
|
|
|
|
function TGtk3ScrollBar.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AScrollbar: TCustomScrollBar;
|
|
ARange: PGtkRange;
|
|
begin
|
|
AScrollBar := TCustomScrollBar(LCLObject);
|
|
FWidgetType := FWidgetType + [wtScrollBar];
|
|
Result := TGtkScrollbar.new(TGtkOrientation(AScrollBar.Kind), nil);
|
|
ARange := PGtkRange(Result);
|
|
with AScrollBar do
|
|
begin
|
|
ARange^.adjustment^.configure(Position, Min, Max + PageSize,
|
|
SmallChange, LargeChange, PageSize);
|
|
ARange^.adjustment^.set_value(Position);
|
|
g_signal_connect_data(ARange^.adjustment,
|
|
'value-changed', TGCallback(@ScrollBarValueChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ScrollBar.SetParams;
|
|
var
|
|
ARange: PGtkRange;
|
|
begin
|
|
if not IsWidgetOk then
|
|
exit;
|
|
ARange := PGtkRange(Widget);
|
|
with TCustomScrollbar(LCLObject) do
|
|
begin
|
|
ARange^.adjustment^.configure(Position, Min, Max,
|
|
SmallChange, LargeChange, PageSize);
|
|
ARange^.adjustment^.set_value(Position);
|
|
ARange^.adjustment^.changed;
|
|
end;
|
|
end;
|
|
|
|
{ TGtk3Calendar }
|
|
|
|
function TGtk3Calendar.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
FWidgetType := [wtWidget, wtCalendar];
|
|
Result := TGtkFrame.new(nil);
|
|
FCentralWidget := TGtkCalendar.new;
|
|
PGtkContainer(Result)^.add(FCentralWidget);
|
|
FCentralWidget^.set_can_focus(True);
|
|
end;
|
|
|
|
procedure TGtk3Calendar.GetDate(out AYear, AMonth, ADay: LongWord);
|
|
begin
|
|
AYear := 0;
|
|
AMonth := 0;
|
|
ADay := 0;
|
|
if IsWidgetOk then
|
|
PGtkCalendar(GetContainerWidget)^.get_date(@AYear, @AMonth, @ADay);
|
|
end;
|
|
|
|
procedure TGtk3Calendar.SetDate(const AYear, AMonth, ADay: LongWord);
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
PGtkCalendar(GetContainerWidget)^.select_month(AMonth, AYear);
|
|
PGtkCalendar(GetContainerWidget)^.select_day(ADay);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Calendar.SetDisplayOptions(
|
|
const ADisplayOptions: TGtkCalendarDisplayOptions);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkCalendar(GetContainerWidget)^.set_display_options(ADisplayOptions);
|
|
end;
|
|
|
|
{ TGtk3StaticText }
|
|
|
|
function TGtk3StaticText.GetAlignment: TAlignment;
|
|
var
|
|
X: gfloat;
|
|
Y: gfloat;
|
|
begin
|
|
Result := taLeftJustify;
|
|
if IsWidgetOK then
|
|
begin
|
|
PGtkLabel(GetContainerWidget)^.get_alignment(@X, @Y);
|
|
if X = 1 then
|
|
Result := taRightJustify
|
|
else
|
|
if X = 0.5 then
|
|
Result := taCenter;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3StaticText.GetStaticBorderStyle: TStaticBorderStyle;
|
|
var
|
|
AShadowType: TGtkShadowType;
|
|
begin
|
|
Result := sbsNone;
|
|
if IsWidgetOK then
|
|
begin
|
|
AShadowType := PGtkFrame(Widget)^.get_shadow_type;
|
|
if AShadowType = GTK_SHADOW_ETCHED_IN then
|
|
Result := sbsSingle
|
|
else
|
|
if AShadowType = GTK_SHADOW_IN then
|
|
Result := sbsSunken;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3StaticText.SetAlignment(AValue: TAlignment);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkLabel(GetContainerWidget)^.set_alignment(AGtkJustificationF[AValue], 0);
|
|
end;
|
|
|
|
procedure TGtk3StaticText.SetStaticBorderStyle(AValue: TStaticBorderStyle);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkFrame(Widget)^.set_shadow_type(StaticBorderShadowMap[AValue]);
|
|
end;
|
|
|
|
function TGtk3StaticText.getText: String;
|
|
begin
|
|
Result := '';
|
|
if IsWidgetOk then
|
|
Result := PGtkLabel(getContainerWidget)^.get_text;
|
|
end;
|
|
|
|
procedure TGtk3StaticText.setText(const AValue: String);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkLabel(getContainerWidget)^.set_text(PgChar(AValue));
|
|
end;
|
|
|
|
function TGtk3StaticText.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AStaticText: TCustomStaticText;
|
|
begin
|
|
FWidgetType := FWidgetType + [wtStaticText];
|
|
AStaticText := TCustomStaticText(LCLObject);
|
|
Result := TGtkFrame.new('');
|
|
PGtkFrame(Result)^.set_shadow_type(StaticBorderShadowMap[AStaticText.BorderStyle]);
|
|
FCentralWidget := TGtkLabel.new('');
|
|
FCentralWidget^.set_has_window(True);
|
|
PGtkFrame(Result)^.set_label_widget(nil);
|
|
PGtkFrame(Result)^.add(FCentralWidget);
|
|
PGtkLabel(FCentralWidget)^.set_alignment(AGtkJustificationF[AStaticText.Alignment], 0.0);
|
|
end;
|
|
|
|
{ TGtk3ProgressBar }
|
|
|
|
function TGtk3ProgressBar.GetOrientation: TProgressBarOrientation;
|
|
var
|
|
AOrientation: TGtkOrientation;
|
|
begin
|
|
Result := pbHorizontal;
|
|
if IsWidgetOk then
|
|
begin
|
|
AOrientation := PGtkOrientable(getContainerWidget)^.get_orientation;
|
|
if AOrientation = GTK_ORIENTATION_HORIZONTAL then
|
|
begin
|
|
if PGtkProgressBar(getContainerWidget)^.get_inverted then
|
|
Result := pbRightToLeft
|
|
else
|
|
Result := pbHorizontal;
|
|
end else
|
|
begin
|
|
if PGtkProgressBar(getContainerWidget)^.get_inverted then
|
|
Result := pbTopDown
|
|
else
|
|
Result := pbVertical;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ProgressBar.GetPosition: Integer;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOk then
|
|
Result := Round(PGtkProgressBar(GetContainerWidget)^.get_fraction);
|
|
end;
|
|
|
|
function TGtk3ProgressBar.GetShowText: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOK then
|
|
Result := PGtkProgressBar(GetContainerWidget)^.get_show_text;
|
|
end;
|
|
|
|
function TGtk3ProgressBar.GetStyle: TProgressBarStyle;
|
|
begin
|
|
Result := pbstNormal;
|
|
if Assigned(LCLObject) and IsWidgetOk then
|
|
Result := TCustomProgressBar(LCLObject).Style;
|
|
end;
|
|
|
|
procedure TGtk3ProgressBar.SetOrientation(AValue: TProgressBarOrientation);
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
case AValue of
|
|
pbHorizontal,pbRightToLeft:
|
|
begin
|
|
PGtkOrientable(GetContainerWidget)^.set_orientation(GTK_ORIENTATION_HORIZONTAL);
|
|
PGtkProgressBar(GetContainerWidget)^.set_inverted(AValue = pbRightToLeft);
|
|
end;
|
|
pbVertical, pbTopDown:
|
|
begin
|
|
PGtkOrientable(GetContainerWidget)^.set_orientation(GTK_ORIENTATION_VERTICAL);
|
|
PGtkProgressBar(GetContainerWidget)^.set_inverted(AValue = pbVertical);
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ProgressBar.SetPosition(AValue: Integer);
|
|
var
|
|
ABar: TCustomProgressBar;
|
|
fraction: gDouble;
|
|
begin
|
|
if not Assigned(LCLObject) or not IsWidgetOK then
|
|
exit;
|
|
ABar := TCustomProgressBar(LCLObject);
|
|
if ((ABar.Max - ABar.Min) <> 0) then
|
|
fraction := (AValue - ABar.Min) / (ABar.Max - ABar.Min)
|
|
else
|
|
fraction := 0;
|
|
PGtkProgressBar(GetContainerWidget)^.set_fraction(fraction);
|
|
end;
|
|
|
|
procedure TGtk3ProgressBar.SetShowText(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkProgressBar(GetContainerWidget)^.set_show_text(AValue);
|
|
end;
|
|
|
|
function ProgressPulseTimeout(data: gpointer): gboolean; cdecl;
|
|
begin
|
|
Result := {%H-}PtrUInt(g_object_get_data(data, 'lclprogressbarstyle')) = 1;
|
|
if Result then
|
|
PGtkProgressBar(Data)^.pulse;
|
|
end;
|
|
|
|
procedure ProgressDestroy(data: gpointer); cdecl;
|
|
begin
|
|
g_source_remove({%H-}PtrUInt(data));
|
|
end;
|
|
|
|
procedure TGtk3ProgressBar.SetStyle(AValue: TProgressBarStyle);
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
g_object_set_data(GetContainerWidget,'lclprogressbarstyle', {%H-}Pointer(PtrUInt(Ord(AValue))));
|
|
if AValue = pbstNormal then
|
|
begin
|
|
Position := TCustomProgressBar(LCLObject).Position;
|
|
end else
|
|
begin
|
|
g_object_set_data_full(GetContainerWidget, 'timeout',
|
|
{%H-}Pointer(PtrUInt(g_timeout_add(100, @ProgressPulseTimeout, GetContainerWidget))), @ProgressDestroy);
|
|
PGtkProgressBar(GetContainerWidget)^.pulse;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{we must override preferred width since gtk3 have strange opinion about minimum width of progress bar}
|
|
procedure get_progress_preferred_width(widget: PGtkWidget; minimum_width: Pgint; natural_width: Pgint); cdecl;
|
|
var
|
|
Handle: HWND;
|
|
begin
|
|
Handle := HwndFromGtkWidget(Widget);
|
|
if Handle <> 0 then
|
|
begin
|
|
minimum_width^ := TGtk3Widget(Handle).LCLObject.Width;
|
|
natural_width^ := TGtk3Widget(Handle).LCLObject.Width;
|
|
end else
|
|
begin
|
|
minimum_width^ := 0;
|
|
natural_width^ := 0;
|
|
DebugLn('ERROR: get_progress_preferred_width cannot find GtkWidget LCL Handle ....');
|
|
end;
|
|
end;
|
|
|
|
{we must override preferred height since gtk3 have strange opinion about height of progress bar}
|
|
procedure get_progress_preferred_height(widget: PGtkWidget; minimum_height: Pgint; natural_height: Pgint); cdecl;
|
|
var
|
|
Handle: HWND;
|
|
begin
|
|
Handle := HwndFromGtkWidget(Widget);
|
|
if Handle <> 0 then
|
|
begin
|
|
minimum_height^ := TGtk3Widget(Handle).LCLObject.Height;
|
|
natural_height^ := TGtk3Widget(Handle).LCLObject.Height;
|
|
// TODO: get spacing from style property
|
|
// Widget^.get_style_context^.get_style_property();
|
|
end else
|
|
begin
|
|
minimum_height^ := 0;
|
|
natural_height^ := 0;
|
|
DebugLn('ERROR: get_progress_preferred_height cannot find GtkWidget LCL Handle ....');
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ProgressBar.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AProgress: TCustomProgressBar;
|
|
begin
|
|
AProgress := TCustomProgressBar(LCLObject);
|
|
if AProgress=nil then ;
|
|
FWidgetType := FWidgetType + [wtProgressBar];
|
|
Result := TGtkEventBox.new;
|
|
FCentralWidget := TGtkProgressBar.new;
|
|
PGtkEventBox(Result)^.add(FCentralWidget);
|
|
FCentralWidget^.set_can_focus(True);
|
|
end;
|
|
|
|
var
|
|
AProgressClassHookInitialized: Boolean = False;
|
|
|
|
procedure TGtk3ProgressBar.InitializeWidget;
|
|
var
|
|
AClass: PGTypeClass;
|
|
begin
|
|
inherited InitializeWidget;
|
|
//TODO: move hook check variable code into Gtk3WidgetSet.
|
|
if not AProgressClassHookInitialized then
|
|
begin
|
|
AProgressClassHookInitialized := True;
|
|
AClass := g_type_class_ref(gtk_progress_bar_get_type);
|
|
PGtkWidgetClass(AClass)^.get_preferred_width := @get_progress_preferred_width;
|
|
PGtkWidgetClass(AClass)^.get_preferred_height := @get_progress_preferred_height;
|
|
g_type_class_unref(AClass);
|
|
end;
|
|
end;
|
|
|
|
{ TGtk3Container }
|
|
|
|
function disableMouseButtonEvent(widget: PGtkWidget; event: PGdkEvent; user_data: gpointer): gboolean; cdecl;
|
|
var
|
|
AEvent: TGdkEvent;
|
|
begin
|
|
Result := TGtk3Widget(user_data).GtkEventMouse(Widget, Event);
|
|
{TODO: check if we can block button_press also}
|
|
if event^.type_ = GDK_BUTTON_RELEASE then
|
|
Result := True;
|
|
end;
|
|
|
|
function motionNotifyEvent(widget: PGtkWidget; event: PGdkEvent; user_data: gpointer): gboolean; cdecl;
|
|
begin
|
|
TGtk3Widget(user_data).GtkEventMouseMove(widget, event);
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TGtk3Container.SetVisible(AValue: Boolean);
|
|
begin
|
|
if not AValue then
|
|
begin
|
|
if [wtNotebook, wtWindow] * WidgetType = [] then
|
|
begin
|
|
Widget^.set_no_show_all(True);
|
|
Widget^.hide;
|
|
end;
|
|
end;
|
|
inherited SetVisible(AValue);
|
|
end;
|
|
|
|
procedure TGtk3Container.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
if IsDesigning then
|
|
begin
|
|
(*
|
|
if (Widget <> getContainerWidget) then
|
|
begin
|
|
//Widget^.set_events([GDK_BUTTON_PRESS_MASK, GDK_BUTTON_RELEASE_MASK]);
|
|
g_signal_connect_data(Widget, 'button-press-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(Widget, 'button-release-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(Widget, 'motion-notify-event', TGCallback(@motionNotifyEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
*)
|
|
g_signal_connect_data(GetContainerWidget, 'button-press-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(GetContainerWidget, 'button-release-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(GetContainerWidget, 'motion-notify-event', TGCallback(@motionNotifyEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
end;
|
|
|
|
{ TGtk3ToolBar }
|
|
|
|
procedure TGtk3ToolBar.ClearGlyphs;
|
|
var i:integer;
|
|
begin
|
|
if Assigned(fBmpList) then
|
|
for i:=fBmpList.Count-1 downto 0 do
|
|
TObject(fBmpList[i]).Free;
|
|
end;
|
|
|
|
destructor TGtk3ToolBar.Destroy;
|
|
begin
|
|
ClearGlyphs;
|
|
fBmpList.Free;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TGtk3ToolBar.ButtonClicked(data: gPointer);cdecl;
|
|
begin
|
|
if TObject(data) is TToolButton then
|
|
TToolButton(data).Click;
|
|
end;
|
|
|
|
function TGtk3ToolBar.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
i:integer;
|
|
AToolBar: TToolBar;
|
|
btn:TToolButton;
|
|
gtb:PGtkToolItem;
|
|
wmenu,wicon:PGtkWidget;
|
|
pb:PGdkPixBuf;
|
|
bmp:TBitmap;
|
|
resolution:TCustomImageListResolution;
|
|
raw:TRawImage;
|
|
bs:string;
|
|
begin
|
|
AToolBar := TToolBar(LCLObject);
|
|
FHasPaint := False;
|
|
FWidgetType := [wtWidget, wtContainer];
|
|
Result:=PGtkWidget(TGtkToolbar.new);
|
|
|
|
if not Assigned(fBmpList) then
|
|
fBmpList:=TList.Create;
|
|
|
|
ClearGlyphs;
|
|
|
|
// allocate appropriate number of tool items
|
|
for i:=0 to AToolbar.ButtonCount-1 do
|
|
begin
|
|
btn:=AToolBar.Buttons[i];
|
|
bs:= ReplaceAmpersandsWithUnderscores(btn.Caption);
|
|
wicon:=nil;
|
|
if btn is TToolButton then
|
|
begin
|
|
if (btn.ImageIndex>=0) and
|
|
assigned(AToolbar.Images) and
|
|
not (btn.Style in [tbsSeparator,tbsDivider]) then
|
|
begin
|
|
if Assigned(AToolBar.Images) and (btn.ImageIndex>=0) then
|
|
begin
|
|
bmp:=TBitmap.Create; { this carries gdk pixmap }
|
|
resolution:=AToolBar.Images.Resolution[AToolBar.ImagesWidth]; // not AToolBar.Images.Width, issue #36465
|
|
resolution.GetRawImage(btn.ImageIndex,raw);
|
|
{ convince the bitmap it has actually another format }
|
|
bmp.BeginUpdate();
|
|
//raw.Description.Init_BPP32_R8G8B8A8_BIO_TTB(resolution.Width,resolution.Height);
|
|
bmp.LoadFromRawImage(raw,false);
|
|
bmp.EndUpdate();
|
|
pb:=TGtk3Image(bmp.Handle).Handle;
|
|
wicon := TGtkImage.new_from_pixbuf(pb);
|
|
fBmpList.Add(bmp);
|
|
end
|
|
else
|
|
wicon := nil;
|
|
end;
|
|
|
|
case btn.Style of
|
|
tbsSeparator:
|
|
gtb:=TGtkSeparatorToolItem.new();
|
|
tbsDropDown:
|
|
begin
|
|
gtb:=TGtkMenuToolButton.new(wicon,PgChar(bs));
|
|
if Assigned(btn.DropdownMenu) then
|
|
begin
|
|
wmenu:=TGtk3Menu(btn.DropdownMenu.Handle).Widget;
|
|
PGtkMenuToolButton(gtb)^.set_menu(wmenu);
|
|
end;
|
|
end;
|
|
tbsCheck:
|
|
begin
|
|
gtb:=TGtkToggleToolButton.new();
|
|
PGtkToolButton(gtb)^.set_label(PgChar(bs));
|
|
PGtkToolButton(gtb)^.set_icon_widget(wicon);
|
|
end
|
|
else
|
|
gtb:=TGtkToolButton.new(wicon,PgChar(bs));
|
|
end;
|
|
if not (btn.Style in [tbsSeparator,tbsDivider]) then
|
|
begin
|
|
gtb^.set_tooltip_text(PgChar(btn.Hint));
|
|
PgtkToolButton(gtb)^.set_use_underline(true);
|
|
end;
|
|
PGtkToolBar(Result)^.add(gtb);
|
|
|
|
if not (btn.Style in [tbsSeparator,tbsDivider]) then
|
|
g_signal_connect_data(gtb,'clicked',
|
|
TGCallback(@TGtk3Toolbar.ButtonClicked), btn, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
end;
|
|
|
|
end;
|
|
|
|
{ TGtk3Page }
|
|
|
|
procedure TGtk3Page.DoBeforeLCLPaint;
|
|
var
|
|
DC: TGtk3DeviceContext;
|
|
NColor: TColor;
|
|
begin
|
|
inherited DoBeforeLCLPaint;
|
|
if not Visible then
|
|
exit;
|
|
DC := TGtk3DeviceContext(Context);
|
|
NColor := LCLObject.Color;
|
|
if (NColor <> clNone) and (NColor <> clDefault) then
|
|
begin
|
|
DC.CurrentBrush.Color := ColorToRGB(NColor);
|
|
DC.fillRect(0, 0, LCLObject.Width, LCLObject.Height);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Page.setText(const AValue: String);
|
|
var
|
|
bs:string;
|
|
begin
|
|
inherited;
|
|
if Assigned(FPageLabel) then
|
|
begin
|
|
bs:=ReplaceAmpersandsWithUnderscores(Avalue);
|
|
FPageLabel^.set_markup_with_mnemonic(PChar(bs));
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Page.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
FWidgetType := FWidgetType + [wtLayout];
|
|
FPageLabel:= TGtkLabel.new(PChar(Params.Caption));
|
|
FPageLabel^.set_use_underline(true);
|
|
Self.FHasPaint:=true;
|
|
// ref it to save it in case TabVisible is set to false
|
|
FPageLabel^.ref;
|
|
Result := TGtkBox.new(GTK_ORIENTATION_HORIZONTAL, 0);
|
|
FCentralWidget := TGtkLayout.new(nil, nil);
|
|
PGtkBox(Result)^.pack_start(FCentralWidget, True , True, 0);
|
|
FCentralWidget^.set_has_window(True);
|
|
// PGtkFixed(FCentralWidget)^.set_can_focus(True);
|
|
end;
|
|
|
|
procedure TGtk3Page.DestroyWidget;
|
|
begin
|
|
// unref it to allow it to be destroyed
|
|
FPageLabel^.unref;
|
|
inherited DestroyWidget;
|
|
end;
|
|
|
|
function TGtk3Page.getClientOffset: TPoint;
|
|
var
|
|
Allocation: TGtkAllocation;
|
|
R: TRect;
|
|
begin
|
|
Self.Widget^.get_allocation(@Allocation);
|
|
Result.X := -Allocation.X;
|
|
Result.Y := -Allocation.Y;
|
|
|
|
R := getClientBounds;
|
|
Result := Point(Result.x + R.Left, Result.y + R.Top);
|
|
end;
|
|
|
|
function TGtk3Page.getClientRect: TRect;
|
|
var
|
|
AParent: PGtkWidget;
|
|
AParentObject: TGtk3Widget;
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
if Assigned(LCLObject.Parent) and (LCLObject.Parent.HandleAllocated) then
|
|
begin
|
|
if not WidgetMapped then
|
|
begin
|
|
Result := TGtk3Widget(LCLObject.Parent.Handle).getClientRect;
|
|
exit;
|
|
end;
|
|
end;
|
|
|
|
if not WidgetMapped then
|
|
begin
|
|
AParent := Widget^.get_parent;
|
|
AParentObject := TGtk3Widget(HwndFromGtkWidget(AParent));
|
|
if AParentObject <> nil then
|
|
Result := AParentObject.getClientRect
|
|
else
|
|
Result := inherited getClientRect;
|
|
end else
|
|
Result := inherited getClientRect;
|
|
// DebugLn('TGtk3Page.GetClientRect Result=',dbgs(Result),' Realized ',dbgs(getContainerWidget^.get_realized));
|
|
end;
|
|
|
|
{ TGtk3NoteBook }
|
|
|
|
function NotebookPageRealToLCLIndex(const ATabControl: TCustomTabControl; AIndex: integer): integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := AIndex;
|
|
if csDesigning in ATabControl.ComponentState then exit;
|
|
I := 0;
|
|
while (I < ATabControl.PageCount) and (I <= Result) do
|
|
begin
|
|
if not ATabControl.Page[I].TabVisible then Inc(Result);
|
|
Inc(I);
|
|
end;
|
|
end;
|
|
|
|
// function GtkNotebookAfterSwitchPage(widget: PGtkWidget; pagenum: integer; data: gPointer): GBoolean; cdecl;
|
|
procedure GtkNotebookAfterSwitchPage(widget: PGtkWidget; {%H-}page: PGtkWidget; pagenum: integer; data: gPointer); cdecl;
|
|
var
|
|
Mess: TLMNotify;
|
|
NMHdr: tagNMHDR;
|
|
LCLPageIndex: Integer;
|
|
begin
|
|
if widget=nil then ;
|
|
if TGtk3Widget(Data).InUpdate then
|
|
exit;
|
|
{page is deleted}
|
|
{ DebugLn('GtkNotebookAfterSwitchPage ');
|
|
if TGtk3NoteBook(Data).getPagesCount < TCustomTabControl(TGtk3NoteBook(Data).LCLObject).PageCount then
|
|
begin
|
|
DebugLn('GtkNotebookAfterSwitchPage PageIsDeleted');
|
|
exit;
|
|
end;}
|
|
FillChar(Mess{%H-}, SizeOf(Mess), 0);
|
|
Mess.Msg := LM_NOTIFY;
|
|
FillChar(NMHdr{%H-}, SizeOf(NMHdr), 0);
|
|
NMHdr.code := TCN_SELCHANGE;
|
|
NMHdr.hwndFrom := HWND(TGtk3Widget(Data));
|
|
LCLPageIndex := NotebookPageRealToLCLIndex(TCustomTabControl(TGtk3Widget(Data).LCLObject), pagenum); //use this to set pageindex to the correct page.
|
|
NMHdr.idFrom := LCLPageIndex;
|
|
Mess.NMHdr := @NMHdr;
|
|
TGtk3Widget(Data).DeliverMessage(Mess);
|
|
end;
|
|
|
|
function BackNoteBookSignal(AData: Pointer): gboolean; cdecl;
|
|
var
|
|
AWidget: PGtkNotebook;
|
|
APageNum: PtrInt;
|
|
ACurrentPage: gint;
|
|
begin
|
|
Result := False;
|
|
AWidget := PGtkNoteBook(AData);
|
|
if not Gtk3IsWidget(AWidget) then
|
|
exit;
|
|
if g_object_get_data(AWidget,'switch-page-signal-stopped') <> nil then
|
|
begin
|
|
Result := True;
|
|
APageNum := {%H-}PtrInt(g_object_get_data(AWidget,'switch-page-signal-stopped'));
|
|
ACurrentPage := AWidget^.get_current_page;
|
|
g_object_set_data(AWidget,'switch-page-signal-stopped', nil);
|
|
{$IFDEF GTK3DEBUGNOTEBOOK}
|
|
DebugLn('BackNoteBookSignal back notebook switch-page signal currpage=',dbgs(AWidget^.get_current_page),' blockedPage ',dbgs(APageNum));
|
|
{$ENDIF}
|
|
if ACurrentPage<0 then ;
|
|
// must hook into notebook^.priv to unlock APageNum
|
|
// AWidget^.set_current_page(AWidget^.get_current_page);
|
|
// g_object_thaw_notify(AWidget^.get_nth_page(AWidget^.get_current_page));
|
|
// PGtkFixed(AWidget^.get_nth_page(AWidget^.get_current_page))^.
|
|
// g_signal_emit_by_name(AWidget,'switch-page',[AWidget^.get_nth_page(APageNum), APageNum, gPointer(HwndFromGtkWidget(AWidget)), nil{AWidget, True, gPointer(HwndFromGtkWidget(AWidget))}]);
|
|
// AWidget^.notify('page');
|
|
// g_signal_stop_emission_by_name(AWidget, 'switch-page');
|
|
// g_signal_emit_by_name(AWidget,'switch-page',[G_TYPE_NONE, AWidget, AWidget^.get_nth_page(AWidget^.get_current_page), AWidget^.get_current_page, gPointer(HwndFromGtkWidget(AWidget))]);
|
|
end;
|
|
g_idle_remove_by_data(AData);
|
|
end;
|
|
|
|
procedure GtkNotebookSwitchPage(widget: PGtkWidget; {%H-}page: PGtkWidget; pagenum: integer; data: gPointer); cdecl;
|
|
var
|
|
Mess: TLMNotify;
|
|
NMHdr: tagNMHDR;
|
|
c1,c2:integer;
|
|
begin
|
|
if TGtk3Widget(Data).InUpdate then
|
|
exit;
|
|
{$IFDEF GTK3DEBUGNOTEBOOK}
|
|
DebugLn('GtkNotebookSwitchPage Data ',dbgHex({%H-}PtrUInt(Data)),' Realized ',dbgs(Widget^.get_realized),' pageNum=',dbgs(pageNum));
|
|
{$ENDIF}
|
|
|
|
{page is deleted}
|
|
{ c1:=TGtk3NoteBook(Data).getPagesCount;
|
|
c2:=TCustomTabControl(TGtk3NoteBook(Data).LCLObject).PageCount;
|
|
if c1 < c2 then
|
|
begin
|
|
DebugLn('GtkNotebookSwitchPage PageIsDeleted ');
|
|
exit;
|
|
end;}
|
|
|
|
FillChar(Mess{%H-}, SizeOf(Mess), 0);
|
|
Mess.Msg := LM_NOTIFY;
|
|
FillChar(NMHdr{%H-}, SizeOf(NMHdr), 0);
|
|
NMHdr.code := TCN_SELCHANGING;
|
|
NMHdr.hwndFrom := HWND(TGtk3Widget(Data));
|
|
NMHdr.idFrom := NotebookPageRealToLCLIndex(TCustomTabControl(TGtk3Widget(Data).LCLObject), pagenum); //use this to set pageindex to the correct page.
|
|
// DebugLn('LCLObject ',dbgsName(TGtk3Widget(Data).LCLObject),' IdFrom ',dbgs(NMHdr.idFrom));
|
|
Mess.NMHdr := @NMHdr;
|
|
Mess.Result := 0;
|
|
// DebugLn('LCLObject ',dbgsName(TGtk3Widget(Data).LCLObject),' sending message ....');
|
|
TGtk3Widget(Data).DeliverMessage(Mess);
|
|
if Mess.Result <> 0 then
|
|
begin
|
|
g_object_set_data(Widget,'switch-page-signal-stopped', {%H-}GPointer(pageNum));
|
|
g_signal_stop_emission_by_name(PGObject(Widget), 'switch-page');
|
|
// GtkNotebookAfterSwitchPage(Widget, page, pagenum, data);
|
|
g_idle_add(@BackNoteBookSignal, Widget);
|
|
Exit;
|
|
end;
|
|
end;
|
|
|
|
function GtkNotebookSelectPage(ANoteBook: PGtkNotebook; p1: gboolean; Data: gPointer): GBoolean; cdecl;
|
|
begin
|
|
// does not trigger for some reason
|
|
if ANoteBook=nil then ;
|
|
if p1 then ;
|
|
if Data=nil then ;
|
|
{$IFDEF GTK3DEBUGNOTEBOOK}
|
|
DebugLn('GtkNotebookSelectPage ');
|
|
{$ENDIF}
|
|
Result:=true;
|
|
end;
|
|
|
|
function TGtk3NoteBook.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
Alloc:TGtkAllocation;
|
|
begin
|
|
FWidgetType := FWidgetType + [wtNotebook];
|
|
Result := LCLGtkNotebookNew;
|
|
FCentralWidget := Result;
|
|
PGtkNoteBook(FCentralWidget)^.set_scrollable(True);
|
|
if (nboHidePageListPopup in TCustomTabControl(LCLObject).Options) then
|
|
PGtkNoteBook(FCentralWidget)^.popup_disable;
|
|
|
|
Alloc.x := Params.X;
|
|
Alloc.y := Params.Y;
|
|
Alloc.Width := Params.Width;
|
|
Alloc.Height := Params.Height;
|
|
|
|
g_signal_connect_data(FCentralWidget,'switch-page', TGCallback(@GtkNotebookSwitchPage), Self, nil, G_CONNECT_DEFAULT);
|
|
// this one triggers after above switch-page
|
|
g_signal_connect_data(FCentralWidget,'switch-page', TGCallback(@GtkNotebookAfterSwitchPage), Self, nil, G_CONNECT_DEFAULT);
|
|
PGtkNotebook(Result)^.set_scrollable(True);
|
|
// those signals doesn't trigger with gtk3-3.6
|
|
// g_signal_connect_data(FCentralWidget,'change-current-page', TGCallback(@GtkNotebookAfterSwitchPage), Self, nil, 0);
|
|
// g_signal_connect_data(FCentralWidget,'select-page', TGCallback(@GtkNotebookSelectPage), Self, nil, 0);
|
|
FCentralWidget^.show_all;
|
|
FCentralWidget^.size_allocate(@Alloc);
|
|
end;
|
|
|
|
procedure TGtk3NoteBook.InitializeWidget;
|
|
begin
|
|
FDefaultClientRect := Rect(0, 0, 0, 0);
|
|
inherited;
|
|
SetTabPosition(TCustomTabControl(LCLObject).TabPosition);
|
|
end;
|
|
|
|
function TGtk3NoteBook.GetTabSize(AWinControl:TWinControl):integer;
|
|
var
|
|
AWidget: PGtkWidget;
|
|
Alloc:TGtkAllocation;
|
|
APage:PGtkWidget;
|
|
APageAlloc:TGtkAllocation;
|
|
R:TRect;
|
|
begin
|
|
Result := 0;
|
|
if not WidgetMapped then
|
|
Result := DefaultClientRect.Height
|
|
else
|
|
begin
|
|
R := getClientRect;
|
|
if PGtkNotebook(GetContainerWidget)^.tab_pos in [GTK_POS_TOP, GTK_POS_BOTTOM] then
|
|
Result := GetContainerWidget^.get_allocated_height - R.Height
|
|
else
|
|
Result := GetContainerWidget^.get_allocated_width - R.Width;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3NoteBook.getClientRect: TRect;
|
|
var
|
|
AAlloc: TGtkAllocation;
|
|
ACurrentPage: gint;
|
|
APage: PGtkWidget;
|
|
ATabSheet:HWND;
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
ACurrentPage := -1;
|
|
if not WidgetMapped then
|
|
begin
|
|
if not IsRectEmpty(FDefaultClientRect) then
|
|
Result := DefaultClientRect
|
|
else
|
|
exit;
|
|
end else
|
|
if PGtkNoteBook(GetContainerWidget)^.get_n_pages = 0 then
|
|
begin
|
|
GetContainerWidget^.get_allocation(@AAlloc);
|
|
Result := RectFromGtkAllocation(AAlloc);
|
|
Types.OffsetRect(Result, -Result.Left, -Result.Top);
|
|
end else
|
|
begin
|
|
ACurrentPage := PGtkNoteBook(GetContainerWidget)^.get_current_page;
|
|
if (ACurrentPage >= 0) then
|
|
begin
|
|
APage := PGtkNoteBook(GetContainerWidget)^.get_nth_page(ACurrentPage);
|
|
ATabSheet := HwndFromGtkWidget(APage);
|
|
if (ATabSheet <> 0) and TGtk3Widget(ATabSheet).WidgetMapped then
|
|
APage^.get_allocation(@AAlloc)
|
|
else
|
|
GetContainerWidget^.get_allocation(@AAlloc);
|
|
Result := RectFromGtkAllocation(AAlloc);
|
|
Types.OffsetRect(Result, -Result.Left, -Result.Top);
|
|
end;
|
|
end;
|
|
// DebugLn('<TGtk3NoteBook.getClientRect Style Result ',dbgs(Result),' ACurrentPage=',ACurrentPage.ToString);
|
|
end;
|
|
|
|
function TGtk3NoteBook.getPagesCount: integer;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOk then
|
|
Result := PGtkNoteBook(GetContainerWidget)^.get_n_pages;
|
|
end;
|
|
|
|
//debugging
|
|
procedure EnumerateChildren(ANotebook: PGtkNoteBook);
|
|
var
|
|
AList: PGList;
|
|
i: Integer;
|
|
AWidget: PGtkWidget;
|
|
AMinimumH, ANaturalH, ANaturalW, AMinimumW: gint;
|
|
begin
|
|
AList := ANoteBook^.get_children;
|
|
for i := 0 to g_list_length(AList) - 1 do
|
|
begin
|
|
AWidget := PGtkWidget(g_list_nth_data(AList, I));
|
|
AWidget^.get_preferred_height(@AMinimumH, @ANaturalH);
|
|
AWidget^.get_preferred_width(@AMinimumW, @ANaturalW);
|
|
DebugLn(Format('Child[%d] MinH %d NatH %d MinW %d NatW %d ALLOCW %d ALLOCH %d child_type %s',
|
|
[I, AMinimumH, ANaturalH, AMinimumW, ANaturalW,
|
|
AWidget^.get_allocated_width, AWidget^.get_allocated_height, g_type_name(ANotebook^.child_type)]));
|
|
end;
|
|
g_list_free(AList);
|
|
end;
|
|
|
|
procedure TGtk3NoteBook.InsertPage(ACustomPage: TCustomPage; AIndex: Integer);
|
|
var
|
|
Gtk3Page: TGtk3Page;
|
|
AMinSize, ANaturalSize: gint;
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
Gtk3Page := TGtk3Page(ACustomPage.Handle);
|
|
with PGtkNoteBook(GetContainerWidget)^ do begin
|
|
insert_page(Gtk3Page.Widget, Gtk3Page.FPageLabel, AIndex);
|
|
// Check why this give sometimes: Gtk-WARNING: Negative content width -1 (allocation 1, extents 1x1) while allocating gadget (node notebook, owner GtkNotebook)
|
|
resize_children;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3NoteBook.MovePage(ACustomPage: TCustomPage; ANewIndex: Integer);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkNoteBook(GetContainerWidget)^.reorder_child(TGtk3Widget(ACustomPage.Handle).Widget, ANewIndex);
|
|
end;
|
|
|
|
procedure TGtk3NoteBook.RemovePage(AIndex: Integer);
|
|
var
|
|
AMinSizeW, AMinSizeH, ANaturalSizeW, ANaturalSizeH: gint;
|
|
NB: PGtkNotebook;
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
NB:=PGtkNotebook(GetContainerWidget);
|
|
NB^.remove_page(AIndex);
|
|
NB^.get_preferred_width(@AMinSizeW, @ANaturalSizeW);
|
|
NB^.get_preferred_height(@AMinSizeH, @ANaturalSizeH);
|
|
NB^.resize_children;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3NoteBook.SetPageIndex(AIndex: Integer);
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
PGtkNotebook(GetContainerWidget)^.set_current_page(AIndex);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3NoteBook.SetShowTabs(const AShowTabs: Boolean);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkNoteBook(GetContainerWidget)^.set_show_tabs(AShowTabs);
|
|
end;
|
|
|
|
procedure TGtk3NoteBook.SetTabPosition(const ATabPosition: TTabPosition);
|
|
const
|
|
GtkPositionTypeMap: array[TTabPosition] of TGtkPositionType =
|
|
(
|
|
{ tpTop } GTK_POS_TOP,
|
|
{ tpBottom } GTK_POS_BOTTOM,
|
|
{ tpLeft } GTK_POS_LEFT,
|
|
{ tpRight } GTK_POS_RIGHT
|
|
);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkNoteBook(GetContainerWidget)^.set_tab_pos(GtkPositionTypeMap[ATabPosition]);
|
|
end;
|
|
|
|
procedure TGtk3NoteBook.SetTabLabelText(AChild: TCustomPage; const AText: String);
|
|
begin
|
|
if IsWidgetOK then
|
|
TGtk3Widget(AChild.Handle).setText(AText);
|
|
end;
|
|
|
|
function TGtk3NoteBook.GetTabLabelText(AChild: TCustomPage): String;
|
|
begin
|
|
if IsWidgetOK then
|
|
Result := TGtk3Widget(AChild.Handle).getText
|
|
else
|
|
Result := '';
|
|
end;
|
|
|
|
{ TGtk3MenuShell }
|
|
|
|
procedure TGtk3MenuShell.Insert(AMenuShell: PGtkMenuShell; APosition: Integer);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkMenuShell(Widget)^.insert(AMenuShell, APosition);
|
|
end;
|
|
|
|
constructor TGtk3MenuShell.Create(const AMenu: TMenu; AMenuBar: PGtkMenuBar);
|
|
begin
|
|
inherited Create;
|
|
MenuObject := AMenu;
|
|
FCentralWidget := nil;
|
|
if AMenuBar <> nil then
|
|
begin
|
|
FOwnWidget := False;
|
|
FWidget := AMenuBar;
|
|
end else
|
|
FOwnWidget := True;
|
|
// Initializes the properties
|
|
// FKeysToEat := [VK_TAB, VK_RETURN, VK_ESCAPE];
|
|
// FHasPaint := False;
|
|
|
|
// FParams := AParams;
|
|
InitializeWidget;
|
|
end;
|
|
|
|
procedure TGtk3MenuShell.InitializeWidget;
|
|
begin
|
|
if FOwnWidget then
|
|
FWidget := CreateWidget(FParams);
|
|
|
|
LCLIntf.SetProp(HWND(Self),'lclwidget',Self);
|
|
end;
|
|
|
|
|
|
{ TGtk3MenuBar }
|
|
|
|
function TGtk3MenuBar.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
FWidgetType := [wtWidget, wtMenuBar];
|
|
Result := TGtkMenuBar.new;
|
|
PGtkMenuBar(Result)^.set_pack_direction(MenuDirection[TMenu(MenuObject).UseRightToLeftAlignment]);
|
|
end;
|
|
|
|
{ TGtk3Menu }
|
|
|
|
function TGtk3Menu.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
FWidgetType := [wtWidget, wtMenu];
|
|
Result := TGtkMenu.new;
|
|
end;
|
|
|
|
constructor TGtk3Menu.CreateFromMenuItem(const AMenuItem: TMenuItem);
|
|
begin
|
|
inherited Create(AMenuItem.GetParentMenu, nil);
|
|
end;
|
|
|
|
{ TGtk3MenuItem }
|
|
|
|
function TGtk3MenuItem.GetCaption: string;
|
|
begin
|
|
Result := '';
|
|
if IsWidgetOK then
|
|
Result := PGtkMenuItem(FWidget)^.get_label;
|
|
end;
|
|
|
|
procedure TGtk3MenuItem.SetCaption(const AValue: string);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkMenuItem(FWidget)^.set_label(PgChar(AValue));
|
|
end;
|
|
|
|
function TGtk3MenuItem.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
ndx:integer;
|
|
pl:PGsList;
|
|
parentMenu:TMenuItem;
|
|
picon:PGtkImage;
|
|
pmenu:PGtkMenuItem;
|
|
pimgmenu:PgtkImageMenuItem absolute pmenu;
|
|
img:TGtk3Image;
|
|
begin
|
|
Result:=nil;
|
|
FWidgetType := [wtWidget, wtMenuItem];
|
|
if MenuItem.Caption = cLineCaption then
|
|
Result := TGtkSeparatorMenuItem.new
|
|
else
|
|
if (MenuItem.HasIcon) then
|
|
begin
|
|
pimgmenu := TGtkImageMenuItem.new();
|
|
MenuItem.UpdateImage(true);
|
|
img:=Tgtk3Image(MenuItem.Bitmap.Handle);
|
|
picon := TGtkImage.new_from_pixbuf(img.Handle);
|
|
pimgmenu^.set_image(picon);
|
|
pimgmenu^.set_always_show_image(true);
|
|
Result:=pimgmenu;
|
|
end else
|
|
if MenuItem.RadioItem and not MenuItem.HasIcon then
|
|
begin
|
|
Result := TGtkRadioMenuItem.new(nil);
|
|
if Assigned(menuItem.Parent) then
|
|
begin
|
|
ndx:=menuItem.Parent.IndexOf(MenuItem);
|
|
if (ndx>0) then
|
|
begin
|
|
ParentMenu:=menuItem.Parent.Items[ndx-1];
|
|
if (ParentMenu.GroupIndex=MenuItem.GroupIndex) then
|
|
begin
|
|
pl:=PGtkRadioMenuItem(TGtk3MenuItem(ParentMenu.Handle).Widget)^.get_group;
|
|
PGtkRadioMenuItem(Result)^.set_group(pl);
|
|
end;
|
|
end;
|
|
end;
|
|
//PGtkRadioMenuItem(Result)^.set_active(MenuItem.Checked);
|
|
end
|
|
else
|
|
if MenuItem.IsCheckItem and not MenuItem.HasIcon then
|
|
begin
|
|
Result := TGtkCheckMenuItem.new;
|
|
PGtkCheckMenuItem(Result)^.set_active(MenuItem.Checked);
|
|
end
|
|
else
|
|
Result := TGtkMenuItem.new;
|
|
|
|
if Assigned(Result) and (MenuItem.Caption <> cLineCaption) {and not MenuItem.HasIcon} then
|
|
begin
|
|
PGtkMenuItem(Result)^.use_underline := True;
|
|
PGtkMenuItem(Result)^.set_label(PgChar(ReplaceAmpersandsWithUnderscores(MenuItem.Caption)));
|
|
PGtkMenuItem(Result)^.set_sensitive(MenuItem.Enabled);
|
|
end;
|
|
|
|
|
|
end;
|
|
|
|
constructor TGtk3MenuItem.Create(const AMenuItem: TMenuItem);
|
|
begin
|
|
inherited Create;
|
|
MenuItem := AMenuItem;
|
|
FOwnWidget := True;
|
|
// Initializes the properties
|
|
// FKeysToEat := [VK_TAB, VK_RETURN, VK_ESCAPE];
|
|
// FHasPaint := False;
|
|
|
|
// FParams := AParams;
|
|
InitializeWidget;
|
|
end;
|
|
|
|
class function TGtk3MenuItem.MenuItemEvent({%H-}AWidget: PGtkWidget; event: PGdkEvent; {%H-}data: GPointer): gboolean; cdecl;
|
|
begin
|
|
Result := False;
|
|
|
|
if not Assigned(Application) or (Assigned(Application) and Application.Terminated) then
|
|
exit;
|
|
|
|
//DebugLn('TGtk3MenuItem.MenuItemEvent triggered ',dbgsName(TGtk3MenuItem(Data).MenuItem),
|
|
// ' ',Gtk3EventToStr(event^.type_));
|
|
|
|
case event^.type_ of
|
|
GDK_DELETE:
|
|
begin
|
|
// DebugLn('****** GDK_DELETE FOR ',dbgsName(TGtk3Widget(Data).LCLObject),' main_level=',dbgs(gtk_main_level));
|
|
end;
|
|
GDK_DESTROY:
|
|
begin
|
|
// DebugLn('****** GDK_DESTROY FOR ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_EXPOSE:
|
|
begin
|
|
// DebugLn('****** GDK_EXPOSE FOR ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
// TGtk3Widget.DrawWidget is attached to 'draw' signal, Expose event doesn't trigger
|
|
// under gtk3.
|
|
// we use 'draw' signal Gtk3DrawEvent()
|
|
// Result := TGtk3Widget(Data).GtkEventPaint(Widget, Event);
|
|
end;
|
|
GDK_MOTION_NOTIFY:
|
|
begin
|
|
// Result := TGtk3Widget(Data).GtkEventMouseMove(Widget, Event);
|
|
end;
|
|
GDK_BUTTON_PRESS:
|
|
begin
|
|
// Result := TGtk3Widget(Data).GtkEventMouse(Widget , Event);
|
|
end;
|
|
GDK_2BUTTON_PRESS:
|
|
begin
|
|
// if not TGtk3Widget(Data).LCLObject.Focused and TGtk3Widget(Data).LCLObject.CanFocus then
|
|
// LCLIntf.SetFocus(HWND(TGtk3Widget(Data)));
|
|
// Result := TGtk3Widget(Data).GtkEventMouse(Widget , Event);
|
|
end;
|
|
GDK_3BUTTON_PRESS:
|
|
begin
|
|
// if not TGtk3Widget(Data).LCLObject.Focused and TGtk3Widget(Data).LCLObject.CanFocus then
|
|
// LCLIntf.SetFocus(HWND(TGtk3Widget(Data)));
|
|
// Result := TGtk3Widget(Data).GtkEventMouse(Widget , Event);
|
|
end;
|
|
GDK_BUTTON_RELEASE:
|
|
begin
|
|
// Result := TGtk3Widget(Data).GtkEventMouse(Widget , Event);
|
|
end;
|
|
GDK_KEY_PRESS:
|
|
begin
|
|
// if Widget^.has_focus then // or (Widget = TGtk3Widget(data).GetContainerWidget) then
|
|
// Result := TGtk3Widget(Data).GtkEventKey(Widget, Event, True);
|
|
end;
|
|
GDK_KEY_RELEASE:
|
|
begin
|
|
// if Widget^.has_focus then // or (Widget = TGtk3Widget(data).GetContainerWidget) then
|
|
// Result := TGtk3Widget(Data).GtkEventKey(Widget, Event, False);
|
|
end;
|
|
|
|
GDK_ENTER_NOTIFY:
|
|
begin
|
|
// TGtk3Widget(Data).GtkEventMouseEnterLeave(Widget, Event);
|
|
end;
|
|
GDK_LEAVE_NOTIFY:
|
|
begin
|
|
// TGtk3Widget(Data).GtkEventMouseEnterLeave(Widget, Event);
|
|
end;
|
|
GDK_FOCUS_CHANGE:
|
|
begin
|
|
//
|
|
end;
|
|
GDK_CONFIGURE:
|
|
begin
|
|
// GDK_CONFIGURE
|
|
end;
|
|
GDK_MAP:
|
|
begin
|
|
// DebugLn('****** GDK_MAP FOR ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_UNMAP:
|
|
begin
|
|
// DebugLn('****** GDK_UNMAP FOR ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_PROPERTY_NOTIFY:
|
|
begin
|
|
// DebugLn('****** GDK_PROPERTY_NOTIFY FOR ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_CLIENT_EVENT:
|
|
begin
|
|
// DebugLn('****** GDK_CLIENT_EVENT FOR ',dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_VISIBILITY_NOTIFY:
|
|
begin
|
|
// Result := TGtk3Widget(Data).GtkEventShowHide(Widget, Event);
|
|
// DebugLn('****** GDK_VISIBILITY_NOTIFY FOR ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
GDK_SCROLL:
|
|
begin
|
|
// DebugLn('****** GDK_SCROLL ' + dbgsName(TGtk3Widget(Data).LCLObject));
|
|
end;
|
|
else
|
|
DebugLn('TGtk3MenuItem.MenuItemEvent unhandled event.');
|
|
end;
|
|
end;
|
|
|
|
class procedure TGtk3MenuItem.MenuItemActivated({%H-}AItem: PGtkMenuItem; AData: GPointer); cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
// DebugLn('Gtk3MenuItemActivated ',dbgsName(TGtk3MenuItem(Adata)));
|
|
if Assigned(TGtk3MenuItem(AData).MenuItem) and (TGtk3MenuItem(AData).Lock=0) then
|
|
begin
|
|
inc(TGtk3MenuItem(AData).Lock);
|
|
try
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
Msg.Msg := LM_ACTIVATE;
|
|
TGtk3MenuItem(AData).MenuItem.Dispatch(Msg);
|
|
finally
|
|
dec(TGtk3MenuItem(AData).Lock);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3MenuItem.InitializeWidget;
|
|
begin
|
|
FWidget := CreateWidget(FParams);
|
|
LCLIntf.SetProp(HWND(Self),'lclwidget',Self);
|
|
|
|
// move signal connections into attach events
|
|
FWidget^.set_events(GDK_DEFAULT_EVENTS_MASK);
|
|
g_signal_connect_data(FWidget, 'event', TGCallback(@MenuItemEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(FWidget,'activate',TGCallBack(@MenuItemActivated), Self, nil, G_CONNECT_DEFAULT);
|
|
// must hide all by default
|
|
// FWidget^.hide;
|
|
end;
|
|
|
|
procedure TGtk3MenuItem.SetCheck(ACheck: boolean);
|
|
begin
|
|
if Self.IsValidHandle and (lock=0) then
|
|
PGtkCheckMenuItem(fWidget)^.active:=ACheck;
|
|
end;
|
|
|
|
|
|
{ TGtk3ScrollableWin}
|
|
|
|
function TGtk3ScrollableWin.GetHScrollBarPolicy: TGtkPolicyType;
|
|
var
|
|
AScrollWin: PGtkScrolledWindow;
|
|
APolicy: TGtkPolicyType;
|
|
begin
|
|
Result := GTK_POLICY_AUTOMATIC;
|
|
AScrollWin := getScrolledWindow;
|
|
if not Gtk3IsScrolledWindow(AScrollWin) then
|
|
exit;
|
|
AScrollWin^.get_policy(@Result, @APolicy);
|
|
end;
|
|
|
|
function TGtk3ScrollableWin.GetVScrollBarPolicy: TGtkPolicyType;
|
|
var
|
|
AScrollWin: PGtkScrolledWindow;
|
|
APolicy: TGtkPolicyType;
|
|
begin
|
|
Result := GTK_POLICY_AUTOMATIC;
|
|
AScrollWin := getScrolledWindow;
|
|
if not Gtk3IsScrolledWindow(AScrollWin) then
|
|
exit;
|
|
AScrollWin^.get_policy(@APolicy, @Result);
|
|
end;
|
|
|
|
procedure TGtk3ScrollableWin.SetBorderStyle(AValue: TBorderStyle);
|
|
begin
|
|
if FBorderStyle=AValue then Exit;
|
|
FBorderStyle:=AValue;
|
|
if IsWidgetOK then
|
|
begin
|
|
if AValue = bsNone then
|
|
getScrolledWindow^.set_shadow_type(GTK_SHADOW_NONE)
|
|
else
|
|
getScrolledWindow^.set_shadow_type(GTK_SHADOW_ETCHED_IN);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ScrollableWin.SetHScrollBarPolicy(AValue: TGtkPolicyType);
|
|
var
|
|
AScrollWin: PGtkScrolledWindow;
|
|
APolicyH, APolicyV: TGtkPolicyType;
|
|
begin
|
|
AScrollWin := getScrolledWindow;
|
|
if not Gtk3IsScrolledWindow(AScrollWin) or IsDesigning then
|
|
exit;
|
|
AScrollWin^.get_policy(@APolicyH, @APolicyV);
|
|
AScrollWin^.set_policy(AValue, APolicyV);
|
|
end;
|
|
|
|
procedure TGtk3ScrollableWin.SetVScrollBarPolicy(AValue: TGtkPolicyType);
|
|
var
|
|
AScrollWin: PGtkScrolledWindow;
|
|
APolicyH, APolicyV: TGtkPolicyType;
|
|
begin
|
|
AScrollWin := getScrolledWindow;
|
|
if not Gtk3IsScrolledWindow(AScrollWin) or IsDesigning then
|
|
exit;
|
|
AScrollWin^.get_policy(@APolicyH, @APolicyV);
|
|
AScrollWin^.set_policy(APolicyH, AValue);
|
|
end;
|
|
|
|
class procedure TGtk3ScrollableWin.ScrolledLayoutSizeAllocate(
|
|
AWidget: PGtkWidget; AGdkRect: PGdkRectangle; Data: gpointer); cdecl;
|
|
var
|
|
hadj, vadj: PGtkAdjustment;
|
|
//aWindow: PGdkWindow;
|
|
//aCtl: TGtk3Widget absolute Data;
|
|
HSize,VSize: integer;
|
|
uWidth, uHeight: guint;
|
|
begin
|
|
{Note: Gtk expects that we set content size and then it calculates scrollbar values. LCL
|
|
is doing opposite, it sets scrollbar values eg via SetScrollInfo and then content should
|
|
be automatically calculated by widgetset. Gtk is crazy about it.
|
|
So, we are in charge here to help both. We save adjusted values
|
|
in setscrollinfo in LCLVAdj and LCLHAdj, so after GtkLayout sends size-allocate with accurate
|
|
content size we apply LCL values to adjustments and everybody is happy.
|
|
TODO: eg TTreeView editor, if scrollbar position is not at lower pos, showing
|
|
editor moves scrollbar to pos 0, if we apply LCL saved value here, then
|
|
editor won't show at all. Maybe moving editor and showing should take into
|
|
account scrollbar position and calculate x,y offset.}
|
|
|
|
hadj := PGtkScrollable(aWidget)^.get_hadjustment;
|
|
vadj := PGtkScrollable(aWidget)^.get_vadjustment;
|
|
|
|
HSize := Max(AGdkRect^.Width, Round(hAdj^.upper));
|
|
VSize := Max(AGdkRect^.Height, Round(vAdj^.upper));
|
|
|
|
PGtkLayout(aWidget)^.get_size(@uWidth, @uHeight);
|
|
if (uWidth <> HSize) or (uHeight <> VSize) then
|
|
PGtkLayout(aWidget)^.set_size(HSize, VSize);
|
|
|
|
if TGtk3Widget(Data).LCLObject.ClientRectNeedsInterfaceUpdate then
|
|
TGtk3Widget(Data).LCLObject.DoAdjustClientRectChange;
|
|
end;
|
|
|
|
class function TGtk3ScrollableWin.CheckIfScrollbarPressed(scrollbar: PGtkWidget; out AMouseOver: boolean;
|
|
const ACheckModifier: TGdkModifierTypeIdx): boolean;
|
|
var
|
|
display: PGdkDisplay;
|
|
seat: PGdkSeat;
|
|
pointer: PGdkDevice;
|
|
screen: PGdkScreen;
|
|
x, y, win_x, win_y: gint;
|
|
allocation: TGtkAllocation;
|
|
state: TGdkModifierType;
|
|
begin
|
|
Result := False;
|
|
AMouseOver := False;
|
|
|
|
display := gdk_display_get_default();
|
|
seat := gdk_display_get_default_seat(display);
|
|
|
|
// Get the pointer device (mouse)
|
|
pointer := gdk_seat_get_pointer(seat);
|
|
|
|
if pointer = nil then
|
|
begin
|
|
DebugLn('WARNING: No pointer device available');
|
|
Exit;
|
|
end;
|
|
|
|
screen := scrollbar^.get_screen;
|
|
if (screen = nil) then
|
|
screen := gdk_screen_get_default;
|
|
|
|
gdk_device_get_position(pointer, @screen, @x, @y);
|
|
gdk_window_get_origin(gtk_widget_get_window(scrollbar), @win_x, @win_y);
|
|
|
|
// Translate the pointer position to the scrollbar's local coordinates
|
|
x := x - win_x;
|
|
y := y - win_y;
|
|
|
|
// Get the scrollbar's allocation (local coordinates)
|
|
gtk_widget_get_allocation(scrollbar, @allocation);
|
|
|
|
// Check if the pointer is within the scrollbar's allocation
|
|
if (x >= allocation.x) and (x < allocation.x + allocation.width) and
|
|
(y >= allocation.y) and (y < allocation.y + allocation.height) then
|
|
begin
|
|
// Get the button state
|
|
gdk_device_get_state(pointer, gtk_widget_get_window(scrollbar), nil, @state);
|
|
AMouseOver := True;
|
|
Result := (ACheckModifier in state);
|
|
{$IFDEF GTK3DEBUGSCROLL}
|
|
if Result then
|
|
DebugLn(Format('Scrollbar is pressed and being dragged pointer x %d y %d',[x, y]))
|
|
else
|
|
DebugLn(Format('Mouse is over the scrollbar but not pressed pointer x %d y %d', [x, y]));
|
|
{$ENDIF}
|
|
end else
|
|
begin
|
|
{$IFDEF GTK3DEBUGSCROLL}
|
|
DebugLn('**** Mouse is not over the scrollbar ****');
|
|
{$ENDIF}
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ScrollableWin.InitializeWidget;
|
|
begin
|
|
LCLVAdj := nil;
|
|
LCLHAdj := nil;
|
|
inherited InitializeWidget;
|
|
end;
|
|
|
|
class function TGtk3ScrollableWin.RangeChangeValue(ARange: PGtkRange;
|
|
AScrollType: TGtkScrollType; AValue: gdouble; AData: gPointer): gboolean;
|
|
cdecl;
|
|
var
|
|
Msg: TLMVScroll;
|
|
MaxValue: gdouble;
|
|
StateFlags: TGtkStateFlags;
|
|
ACtl: TGtk3ScrollableWin;
|
|
begin
|
|
Result := gtk_false;
|
|
|
|
{$IFDEF GTK3DEBUGSCROLL}
|
|
DebugLn(Format('>TGtk3ScrollableWin.RangeChangeValue Value: %d', [Round(AValue)]),' IsHScrollBar ',dbgs(PGtkOrientable(ARange)^.get_orientation = GTK_ORIENTATION_HORIZONTAL),' InUpdate=',dbgs(TGtk3Widget(AData).InUpdate));
|
|
{$ENDIF}
|
|
ACtl := TGtk3ScrollableWin(aData);
|
|
if PGtkOrientable(ARange)^.get_orientation = GTK_ORIENTATION_HORIZONTAL then
|
|
Msg.Msg := LM_HSCROLL
|
|
else
|
|
Msg.Msg := LM_VSCROLL;
|
|
|
|
if ARange^.adjustment^.page_size > 0 then
|
|
begin
|
|
{we must use cached values since gtk3 has it's own meaning about page_size}
|
|
if Msg.Msg = LM_HSCROLL then
|
|
MaxValue := ACtl.LCLHAdj^.upper - ACtl.LCLHAdj^.page_size
|
|
else
|
|
MaxValue := ACtl.LCLVAdj^.upper - ACtl.LCLVAdj^.page_size;
|
|
end else
|
|
MaxValue := ARange^.adjustment^.upper;
|
|
|
|
if (AValue > MaxValue) then
|
|
AValue := MaxValue
|
|
else if (AValue < ARange^.adjustment^.lower) then
|
|
AValue := ARange^.adjustment^.lower;
|
|
|
|
with Msg do
|
|
begin
|
|
Pos := Round(AValue);
|
|
if Pos < High(SmallPos) then
|
|
SmallPos := Pos
|
|
else
|
|
SmallPos := High(SmallPos);
|
|
{$note to get this correct we must use TQtWidget.CreateFrom() for scrollbars}
|
|
ScrollBar := HWND(TGtk3Widget(AData)); // HWND({%H-}PtrUInt(ARange));
|
|
ScrollCode := Gtk3ScrollTypeToScrollCode(AScrollType);
|
|
end;
|
|
TGtk3Widget(AData).DeliverMessage(Msg, True);
|
|
|
|
if Msg.Scrollcode = SB_THUMBTRACK then
|
|
begin
|
|
StateFlags := ARange^.get_state_flags;
|
|
if not (GTK_STATE_FLAG_ACTIVE in StateFlags) then
|
|
begin
|
|
Msg.ScrollCode := SB_THUMBPOSITION;
|
|
TGtk3Widget(AData).DeliverMessage(Msg, False);
|
|
Msg.ScrollCode := SB_ENDSCROLL;
|
|
TGtk3Widget(AData).DeliverMessage(Msg, False);
|
|
end;
|
|
end else
|
|
ARange^.set_state_flags([GTK_STATE_FLAG_ACTIVE], True);
|
|
|
|
if ([wtScrollingWinControl, wtWindow, wtHintWindow, wtDialog] * TGtk3Widget(AData).WidgetType <> []) and
|
|
((Msg.ScrollCode = SB_LINEUP) or (Msg.ScrollCode = SB_LINEDOWN)) then
|
|
Result := gtk_true;
|
|
{$IFDEF GTK3DEBUGSCROLL}
|
|
DebugLn('<RangeChangeValue: Result=',dbgs(Result),' FuturePos=', dbgs(Msg.Pos),' ScrollCode=',dbgs(Msg.ScrollCode),' InUpdate=',dbgs(TGtk3Widget(AData).InUpdate));
|
|
{$ENDIF}
|
|
end;
|
|
|
|
class procedure TGtk3ScrollableWin.RangeValueChanged(range: PGtkRange;
|
|
data: gpointer); cdecl;
|
|
var
|
|
PrevValue, CurrentValue, Delta: gdouble;
|
|
Control: TGtk3ScrollableWin;
|
|
Msg: TLMVScroll;
|
|
APressed, AMouseOver: boolean;
|
|
Adjustment: PGtkAdjustment;
|
|
begin
|
|
Control := TGtk3ScrollableWin(data);
|
|
{$IFDEF GTK3DEBUGSCROLL}
|
|
writeln('>TGtk3ScrollableWin.RangeValueChanged ', dbgsName(Control.LCLObject), ' InUpdate=', Control.InUpdate);
|
|
{$ENDIF}
|
|
if Control.InUpdate then
|
|
begin
|
|
{$IFDEF GTK3DEBUGSCROLL}
|
|
writeln('<TGtk3ScrollableWin.RangeValueChanged exiting because of InUpdate lock.');
|
|
{$ENDIF}
|
|
exit;
|
|
end else
|
|
begin
|
|
{$IFDEF GTK3DEBUGSCROLL}
|
|
writeln(' setting InUpdate lock.');
|
|
{$ENDIF}
|
|
Control.BeginUpdate;
|
|
end;
|
|
|
|
Adjustment := gtk_range_get_adjustment(range);
|
|
CurrentValue := gtk_adjustment_get_value(Adjustment);
|
|
PrevValue := gtk_adjustment_get_lower(Adjustment); // Store the previous position before it changes
|
|
|
|
Delta := CurrentValue - PrevValue;
|
|
|
|
if Delta <> 0 then
|
|
begin
|
|
if gtk_orientable_get_orientation(PGtkOrientable(range)) = GTK_ORIENTATION_VERTICAL then
|
|
begin
|
|
Msg.Msg := LM_VSCROLL;
|
|
end
|
|
else
|
|
begin
|
|
Msg.Msg := LM_HSCROLL;
|
|
end;
|
|
|
|
APressed := Control.CheckIfScrollbarPressed(PGtkScrollBar(range), AMouseOver, GDK_BUTTON1_MASK);
|
|
if APressed then
|
|
Msg.ScrollCode := SB_THUMBTRACK
|
|
else
|
|
Msg.ScrollCode := SB_THUMBPOSITION;
|
|
|
|
Msg.Pos := Round(CurrentValue);
|
|
Msg.ScrollBar := HWND(Control);
|
|
|
|
Control.DeliverMessage(Msg);
|
|
end;
|
|
|
|
{$IFDEF GTK3DEBUGSCROLL}
|
|
WriteLn('<TGtk3ScrollableWin.RangeValueChanged: CurrentValue=', CurrentValue:0:2, ', PrevValue=', PrevValue:0:2,
|
|
', Delta=', Delta:0:2, ', InUpdate=', Control.InUpdate, ' releasing lock ...');
|
|
{$ENDIF}
|
|
Control.EndUpdate;
|
|
end;
|
|
|
|
procedure TGtk3ScrollableWin.DestroyWidget;
|
|
begin
|
|
if Assigned(LCLHAdj) then
|
|
LCLHAdj^.unref;
|
|
if Assigned(LCLVAdj) then
|
|
LCLVAdj^.unref;
|
|
LCLHAdj := nil;
|
|
LCLVAdj := nil;
|
|
inherited DestroyWidget;
|
|
end;
|
|
|
|
procedure TGtk3ScrollableWin.SetScrollBarsSignalHandlers(const
|
|
AIsHorizontalScrollBar:boolean);
|
|
begin
|
|
{TODO: create real instances for scrollbars via TGtk3Widget.CreateFrom() ?}
|
|
if IsDesigning then
|
|
exit;
|
|
FBorderStyle := bsNone;
|
|
if AIsHorizontalScrollBar then
|
|
begin
|
|
if not FHBarInitialized then
|
|
g_signal_connect_data(getHorizontalScrollbar, 'change-value',
|
|
TGCallback(@RangeChangeValue), Self, nil, G_CONNECT_DEFAULT);
|
|
FHBarInitialized := True;
|
|
end else
|
|
begin
|
|
if not FVBarInitialized then
|
|
g_signal_connect_data(getVerticalScrollbar, 'change-value',
|
|
TGCallback(@RangeChangeValue), Self, nil, G_CONNECT_DEFAULT);
|
|
FVBarInitialized := True;
|
|
end;
|
|
end;
|
|
|
|
{$IFDEF GTK3DEBUGSIZE}
|
|
function GetViewportClientAreaWithScrollbars(ScrolledWindow: PGtkScrolledWindow): TRect;
|
|
var
|
|
Viewport: PGtkViewport;
|
|
ViewportAllocation, HScrollbarAllocation, VScrollbarAllocation: TGtkAllocation;
|
|
Padding, Border: TGtkBorder;
|
|
HScrollbar, VScrollbar: PGtkWidget;
|
|
HScrollbarHeight, VScrollbarWidth: Integer;
|
|
ScrollPolicyH, ScrollPolicyV: TGtkPolicyType;
|
|
StyleContext: PGtkStyleContext;
|
|
begin
|
|
|
|
FillChar(Result, SizeOf(Result), 0);
|
|
HScrollbarHeight := 0;
|
|
VScrollbarWidth := 0;
|
|
|
|
Viewport := PGtkViewport(gtk_bin_get_child(PGtkBin(ScrolledWindow)));
|
|
if Viewport = nil then
|
|
begin
|
|
writeln('Viewport not found.');
|
|
Exit;
|
|
end;
|
|
|
|
gtk_widget_get_allocation(PGtkWidget(Viewport), @ViewportAllocation);
|
|
|
|
//Get the style context for padding and border
|
|
StyleContext := gtk_widget_get_style_context(PGtkWidget(Viewport));
|
|
FillChar(Padding, SizeOf(Padding), 0);
|
|
FillChar(Border, SizeOf(Border), 0);
|
|
|
|
|
|
gtk_style_context_get_padding(StyleContext, GTK_STATE_FLAG_NORMAL, @Padding);
|
|
gtk_style_context_get_border(StyleContext, GTK_STATE_FLAG_NORMAL, @Border);
|
|
|
|
// Check scrollbar visibility policies
|
|
gtk_scrolled_window_get_policy(ScrolledWindow, @ScrollPolicyH, @ScrollPolicyV);
|
|
|
|
//Check if the horizontal scrollbar is visible
|
|
HScrollbar := gtk_scrolled_window_get_hscrollbar(ScrolledWindow);
|
|
if (HScrollbar <> nil) and gtk_widget_get_visible(HScrollbar) and (ScrollPolicyH <> GTK_POLICY_NEVER) then
|
|
begin
|
|
gtk_widget_get_allocation(HScrollbar, @HScrollbarAllocation);
|
|
HScrollbarHeight := HScrollbarAllocation.height;
|
|
end;
|
|
|
|
//Check if the vertical scrollbar is visible
|
|
VScrollbar := gtk_scrolled_window_get_vscrollbar(ScrolledWindow);
|
|
if (VScrollbar <> nil) and gtk_widget_get_visible(VScrollbar) and (ScrollPolicyV <> GTK_POLICY_NEVER) then
|
|
begin
|
|
gtk_widget_get_allocation(VScrollbar, @VScrollbarAllocation);
|
|
VScrollbarWidth := VScrollbarAllocation.width;
|
|
end;
|
|
|
|
//Now we calculate the client area.
|
|
Result.Left := ViewportAllocation.x + Border.left + Padding.left;
|
|
Result.Top := ViewportAllocation.y + Border.top + Padding.top;
|
|
Result.Right := ViewportAllocation.x + ViewportAllocation.width - Border.right - Padding.right - VScrollbarWidth;
|
|
Result.Bottom := ViewportAllocation.y + ViewportAllocation.height - Border.bottom - Padding.bottom - HScrollbarHeight;
|
|
|
|
writeln(Format('Client Area Calculation: Left=%d, Top=%d, Right=%d, Bottom=%d',
|
|
[Result.Left, Result.Top, Result.Right, Result.Bottom]));
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function TGtk3ScrollableWin.getClientBounds: TRect;
|
|
var
|
|
Allocation: TGtkAllocation;
|
|
x:gint;
|
|
y:gint;
|
|
w:gint;
|
|
h:gint;
|
|
AViewport:PGtkViewport;
|
|
AWindow:PGdkWindow;
|
|
VOffset, HOffset:gint;
|
|
Bar:PGtkScrollbar;
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
if IsWidgetOK then
|
|
begin
|
|
(*
|
|
if (Self is TGtk3CustomControl) then
|
|
begin
|
|
if Self is TGtk3Window then
|
|
Result := GetViewportClientAreaWithScrollbars(PGtkScrolledWindow(TGtk3Window(Self).FScrollWin))
|
|
else
|
|
Result := GetViewportClientAreaWithScrollbars(PGtkScrolledWindow(FWidget));
|
|
//DebugLn('TGtk3ScrollableWin.getClientBounds result ',dbgs(Result),' from viewport ',dbgsName(LCLObject));
|
|
exit;
|
|
end else
|
|
*)
|
|
if [wtLayout] * WidgetType <> [] then
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
AWindow := PGtkLayout(getContainerWidget)^.get_window;
|
|
if Assigned(AWindow) and Gtk3IsGdkWindow(AWindow) then
|
|
begin
|
|
Bar := getHorizontalScrollbar;
|
|
if (Bar <> nil) and Gtk3IsWidget(Bar) and Bar^.get_visible and GTK3WidgetSet.OverlayScrolling then
|
|
HOffset := Bar^.get_allocated_height
|
|
else
|
|
HOffset := 0;
|
|
Bar := getVerticalScrollbar;
|
|
if (Bar <> nil) and Gtk3IsWidget(Bar) and Bar^.get_visible and GTK3WidgetSet.OverlayScrolling then
|
|
VOffset := Bar^.get_allocated_width
|
|
else
|
|
VOffset := 0;
|
|
AWindow^.get_geometry(@x, @y, @w, @h);
|
|
Result := Bounds(x, y, w - VOffset, h - HOffset);
|
|
end;
|
|
OffsetRect(Result, -Result.Left, -Result.Top);
|
|
exit;
|
|
end;
|
|
AViewport := getViewPort;
|
|
if Assigned(AViewport) and Gtk3IsGdkWindow(AViewport^.get_view_window) then
|
|
begin
|
|
AWindow := AViewport^.get_view_window;
|
|
if Assigned(AWindow) then
|
|
begin
|
|
Bar := getHorizontalScrollbar;
|
|
if (Bar <> nil) and Gtk3IsWidget(Bar) and Bar^.get_visible and GTK3WidgetSet.OverlayScrolling then
|
|
HOffset := Bar^.get_allocated_height
|
|
else
|
|
HOffset := 0;
|
|
Bar := getVerticalScrollbar;
|
|
if (Bar <> nil) and Gtk3IsWidget(Bar) and Bar^.get_visible and GTK3WidgetSet.OverlayScrolling then
|
|
VOffset := Bar^.get_allocated_width
|
|
else
|
|
VOffset := 0;
|
|
AViewPort^.get_view_window^.get_geometry(@x, @y, @w, @h);
|
|
Result := Bounds(x, y, w - VOffset, h - HOffset);
|
|
end else
|
|
begin
|
|
AViewPort^.get_allocation(@Allocation);
|
|
Result := RectFromGtkAllocation(Allocation);
|
|
end;
|
|
end else
|
|
begin
|
|
getContainerWidget^.get_allocation(@Allocation);
|
|
Result := RectFromGtkAllocation(Allocation);
|
|
end;
|
|
end;
|
|
if (Self is TGtk3Window) then
|
|
exit;
|
|
{$IFDEF GTK3DEBUGSIZE}
|
|
if Assigned(AViewPort) then
|
|
DebugLn('TGtk3ScrollableWin.getClientBounds result ',dbgs(Result),' from viewport ',dbgsName(LCLObject))
|
|
else
|
|
;//DebugLn('TGtk3ScrollableWin.getClientBounds result ',dbgs(Result),' no viewport ',dbgsName(LCLObject));
|
|
{$ENDIF}
|
|
end;
|
|
|
|
function TGtk3ScrollableWin.getViewport:PGtkViewport;
|
|
begin
|
|
Result := nil;
|
|
end;
|
|
|
|
{ TGtk3Memo }
|
|
|
|
function TGtk3Memo.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AMemo: TCustomMemo;
|
|
ABuffer: PGtkTextBuffer;
|
|
AScrollStyle: TGtkScrollStyle;
|
|
begin
|
|
|
|
FKeysToEat := [];
|
|
AMemo := TCustomMemo(LCLObject);
|
|
|
|
FWidgetType := FWidgetType + [wtMemo, wtScrollingWin];
|
|
Result := PGtkScrolledWindow(TGtkScrolledWindow.new(nil, nil));
|
|
|
|
FCentralWidget := PGtkTextView(TGtkTextView.new);
|
|
|
|
FCentralWidget^.set_has_window(True);
|
|
|
|
if AMemo.WordWrap then
|
|
PGtkTextView(FCentralWidget)^.set_wrap_mode(GTK_WRAP_WORD)
|
|
else
|
|
PGtkTextView(FCentralWidget)^.set_wrap_mode(GTK_WRAP_NONE);
|
|
|
|
ABuffer := PGtkTextBuffer^.new(PGtkTextTagTable^.new);
|
|
{%H-}ABuffer^.set_text(PgChar(AMemo.Text), -1);
|
|
PGtkTextView(FCentralWidget)^.set_buffer(ABuffer);
|
|
|
|
PGtkScrolledWindow(Result)^.add(FCentralWidget);
|
|
|
|
AScrollStyle := Gtk3TranslateScrollStyle(AMemo.ScrollBars);
|
|
|
|
//memo without scrollbars still grows if policy is NEVER, so cheat gtk.
|
|
if AScrollStyle.Horizontal = GTK_POLICY_NEVER then
|
|
AScrollStyle.Horizontal := GTK_POLICY_EXTERNAL;
|
|
if AScrollStyle.Vertical = GTK_POLICY_NEVER then
|
|
AScrollStyle.Vertical := GTK_POLICY_EXTERNAL;
|
|
|
|
PGtkScrolledWindow(Result)^.set_policy(AScrollStyle.Horizontal, AScrollStyle.Vertical);
|
|
|
|
PGtkScrolledWindow(Result)^.set_shadow_type(BorderStyleShadowMap[AMemo.BorderStyle]);
|
|
PGtkScrolledWindow(Result)^.get_vscrollbar^.set_can_focus(False);
|
|
PGtkScrolledWindow(Result)^.get_hscrollbar^.set_can_focus(False);
|
|
|
|
FCentralWidget^.set_can_focus(True);
|
|
PGtkScrolledWindow(Result)^.set_can_focus(False);
|
|
end;
|
|
|
|
function TGtk3Memo.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TGtk3Memo.getHorizontalScrollbar: PGtkScrollbar;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result := PGtkScrollBar(PGtkScrolledWindow(Widget)^.get_hscrollbar);
|
|
if Result <> nil then
|
|
SetScrollBarsSignalHandlers(True);
|
|
end;
|
|
|
|
function TGtk3Memo.getVerticalScrollbar: PGtkScrollbar;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result := PGtkScrollBar(PGtkScrolledWindow(Widget)^.get_vscrollbar);
|
|
if Result <> nil then
|
|
SetScrollBarsSignalHandlers(False);
|
|
end;
|
|
|
|
function TGtk3Memo.GetScrolledWindow: PGtkScrolledWindow;
|
|
begin
|
|
if IsWidgetOK then
|
|
Result := PGtkScrolledWindow(Widget)
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TGtk3Memo.getSelStart: Integer;
|
|
var
|
|
AStart, AStop: gint;
|
|
ATextView: PGtkTextView;
|
|
ATextBuffer: PGtkTextBuffer;
|
|
ATextMark: PGtkTextMark;
|
|
ATextIter, AStartIter, AEndIter: TGtkTextIter;
|
|
begin
|
|
Result := 0;
|
|
ATextView := PGtkTextView(GetContainerWidget);
|
|
ATextBuffer := gtk_text_view_get_buffer(ATextView);
|
|
ATextMark := gtk_text_buffer_get_insert(ATextBuffer);
|
|
gtk_text_buffer_get_iter_at_mark(ATextBuffer, @ATextIter, ATextMark);
|
|
|
|
Result := gtk_text_iter_get_offset(@ATextIter);
|
|
if getSelLength = 0 then Exit;
|
|
|
|
if not gtk_text_buffer_get_selection_bounds(ATextBuffer, @AStartIter, @AEndIter) then
|
|
exit;
|
|
|
|
AStart := gtk_text_iter_get_offset(@AStartIter);
|
|
AStop := gtk_text_iter_get_offset(@AEndIter);
|
|
|
|
Result := Min(AStart, AStop);
|
|
end;
|
|
|
|
function TGtk3Memo.getSelLength: Integer;
|
|
var
|
|
ATextView: PGtkTextView;
|
|
ATextBuffer: PGtkTextBuffer;
|
|
AStartIter, AEndIter: TGtkTextIter;
|
|
begin
|
|
Result := 0;
|
|
ATextView := PGtkTextView(GetContainerWidget);
|
|
ATextBuffer := gtk_text_view_get_buffer(ATextView);
|
|
if not gtk_text_buffer_get_selection_bounds(ATextBuffer, @AStartIter, @AEndIter) then
|
|
exit;
|
|
Result := Abs(gtk_text_iter_get_offset(@AEndIter) - gtk_text_iter_get_offset(@AStartIter));
|
|
end;
|
|
|
|
procedure TGtk3Memo.setSelStart(AValue: Integer);
|
|
var
|
|
AIter: TGtkTextIter;
|
|
ATextView: PGtkTextView;
|
|
begin
|
|
if not IsWidgetOk then
|
|
exit;
|
|
ATextView := PGtkTextView(GetContainerWidget);
|
|
gtk_text_buffer_get_iter_at_offset(ATextView^.get_buffer, @AIter, AValue);
|
|
gtk_text_buffer_place_cursor(ATextView^.get_buffer, @AIter);
|
|
end;
|
|
|
|
procedure TGtk3Memo.setSelLength(AValue: Integer);
|
|
var
|
|
AStart: gint;
|
|
AStop: gint;
|
|
ATextView: PGtkTextView;
|
|
ATextBuffer: PGtkTextBuffer;
|
|
AStartIter, AEndIter: TGtkTextIter;
|
|
begin
|
|
if not IsWidgetOk then
|
|
exit;
|
|
ATextView := PGtkTextView(GetContainerWidget);
|
|
ATextBuffer := ATextView^.get_buffer;
|
|
AStart := getSelStart;
|
|
gtk_text_buffer_get_iter_at_offset(ATextBuffer, @AStartIter, AStart);
|
|
gtk_text_buffer_get_iter_at_offset(ATextBuffer, @AEndIter, AStart + AValue);
|
|
gtk_text_buffer_select_range(ATextBuffer, @AStartIter, @AEndIter);
|
|
end;
|
|
|
|
procedure TGtk3Memo.setSelText(const ANewSelText: string);
|
|
var
|
|
StartIter, EndIter: TGtkTextIter;
|
|
AText: PChar;
|
|
StartPos: gint;
|
|
Buffer: PGtkTextBuffer;
|
|
begin
|
|
Buffer := PGtkTextView(GetContainerWidget)^.get_buffer;
|
|
gtk_text_buffer_get_start_iter(Buffer, @StartIter);
|
|
gtk_text_buffer_get_end_iter(Buffer, @EndIter);
|
|
AText := gtk_text_buffer_get_text(Buffer, @StartIter, @EndIter, False);
|
|
StartPos := Pos(ANewSelText, StrPas(AText)) - 1;
|
|
if StartPos >= 0 then
|
|
begin
|
|
gtk_text_buffer_get_iter_at_offset(Buffer, @StartIter, StartPos);
|
|
gtk_text_buffer_get_iter_at_offset(Buffer, @EndIter, StartPos + Length(ANewSelText));
|
|
gtk_text_buffer_select_range(Buffer, @StartIter, @EndIter);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Memo.GetAlignment: TAlignment;
|
|
var
|
|
AJustification: TGtkJustification;
|
|
begin
|
|
Result := taLeftJustify;
|
|
if IsWidgetOk then
|
|
begin
|
|
AJustification := PGtkTextView(GetContainerWidget)^.get_justification;
|
|
if AJustification = GTK_JUSTIFY_RIGHT then
|
|
Result := taRightJustify
|
|
else
|
|
if AJustification = GTK_JUSTIFY_CENTER then
|
|
Result := taCenter;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Memo.GetCaretPos: TPoint;
|
|
var
|
|
ATextView: PGtkTextView;
|
|
ATextBuffer: PGtkTextBuffer;
|
|
AIter: TGtkTextIter;
|
|
AOffset: Integer;
|
|
Rect: TGdkRectangle;
|
|
YTop, YBottom: gint;
|
|
begin
|
|
ATextView := PGtkTextView(GetContainerWidget);
|
|
ATextBuffer := gtk_text_view_get_buffer(ATextView);
|
|
|
|
AOffset := GetSelStart - GetSelLength;
|
|
gtk_text_buffer_get_iter_at_offset(ATextBuffer, @AIter, AOffset);
|
|
gtk_text_view_get_iter_location(ATextView, @AIter, @Rect);
|
|
gtk_text_view_get_line_yrange(ATextView, @AIter, @YTop, @YBottom);
|
|
Result.Y := gtk_text_iter_get_line(@AIter);
|
|
if Rect.y > YTop then
|
|
Result.Y := Result.Y + ((Rect.y - YTop) div (YBottom - YTop));
|
|
Result.X := gtk_text_iter_get_line_offset(@AIter);
|
|
end;
|
|
|
|
function TGtk3Memo.GetReadOnly: Boolean;
|
|
begin
|
|
Result := True;
|
|
if IsWidgetOk then
|
|
Result := not PGtkTextView(GetContainerWidget)^.get_editable;
|
|
end;
|
|
|
|
function TGtk3Memo.GetWantTabs: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOK then
|
|
Result := PGtkTextView(GetContainerWidget)^.get_accepts_tab;
|
|
end;
|
|
|
|
function TGtk3Memo.GetWordWrap: Boolean;
|
|
begin
|
|
Result := True;
|
|
if IsWidgetOk then
|
|
Result := PGtkTextView(GetContainerWidget)^.get_wrap_mode = GTK_WRAP_WORD;
|
|
end;
|
|
|
|
procedure TGtk3Memo.SetAlignment(AValue: TAlignment);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkTextView(GetContainerWidget)^.set_justification(AGtkJustification[AValue]);
|
|
end;
|
|
|
|
procedure TGtk3Memo.SetCaretPos(AValue: TPoint);
|
|
var
|
|
Iter: TGtkTextIter;
|
|
ABuffer: PGtkTextBuffer;
|
|
begin
|
|
ABuffer := gtk_text_view_get_buffer(PGtkTextView(getContainerWidget));
|
|
gtk_text_buffer_get_iter_at_offset(ABuffer, @Iter, AValue.X);
|
|
gtk_text_buffer_place_cursor(ABuffer, @Iter);
|
|
end;
|
|
|
|
procedure TGtk3Memo.SetReadOnly(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOk then
|
|
PGtkTextView(GetContainerWidget)^.set_editable(not AValue);
|
|
end;
|
|
|
|
procedure TGtk3Memo.SetWantTabs(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkTextView(GetContainerWidget)^.set_accepts_tab(AValue);
|
|
end;
|
|
|
|
procedure TGtk3Memo.SetWordWrap(AValue: Boolean);
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
if AValue then
|
|
PGtkTextView(GetContainerWidget)^.set_wrap_mode(GTK_WRAP_WORD)
|
|
else
|
|
PGtkTextView(GetContainerWidget)^.set_wrap_mode(GTK_WRAP_NONE);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Memo.getText: String;
|
|
var
|
|
ABuffer: PGtkTextBuffer;
|
|
AIter: TGtkTextIter;
|
|
ALastIter: TGtkTextIter;
|
|
begin
|
|
Result := '';
|
|
if IsWidgetOk then
|
|
begin
|
|
ABuffer := PGtkTextView(FCentralWidget)^.get_buffer;
|
|
ABuffer^.get_start_iter(@AIter);
|
|
ABuffer^.get_end_iter(@ALastIter);
|
|
Result := ABuffer^.get_text(@AIter, @ALastIter, False);
|
|
end;
|
|
// DebugLn('TGtk3Memo.getText Result=',Result);
|
|
end;
|
|
|
|
procedure TGtk3Memo.setText(const AValue: String);
|
|
var
|
|
ABuffer: PGtkTextBuffer;
|
|
AIter: PGtkTextIter;
|
|
begin
|
|
// DebugLn('TGtk3Memo.setText AValue=',AValue);
|
|
if IsWidgetOk then
|
|
begin
|
|
ABuffer := PGtkTextView(FCentralWidget)^.get_buffer;
|
|
ABuffer^.set_text(PgChar(AValue), -1);
|
|
AIter:=nil;
|
|
ABuffer^.get_start_iter(AIter);
|
|
ABuffer^.place_cursor(AIter);
|
|
end;
|
|
end;
|
|
|
|
{ TGtk3ListBox }
|
|
|
|
procedure Gtk3ListBoxSelectionChanged({%H-}ASelection: PGtkTreeSelection; AData: GPointer); cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
// DebugLn('Gtk3ListBoxSelectionChanged ');
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
Msg.Msg := LM_SELCHANGE;
|
|
if not TGtk3Widget(AData).InUpdate then
|
|
TGtk3Widget(AData).DeliverMessage(Msg, False);
|
|
end;
|
|
|
|
procedure FreeStoreStringList(aData: gpointer); cdecl;
|
|
begin
|
|
TGtkListStoreStringList(aData).Free;
|
|
end;
|
|
|
|
|
|
function TGtk3ListBox.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AListBox: TCustomListBox;
|
|
ListStore: PGtkListStore;
|
|
ItemList: TGtkListStoreStringList;
|
|
AColumn: PGtkTreeViewColumn;
|
|
Renderer : PGtkCellRenderer;
|
|
begin
|
|
FListBoxStyle := lbStandard;
|
|
|
|
FWidgetType := FWidgetType + [wtTreeModel, wtListBox, wtScrollingWin];
|
|
AListBox := TCustomListBox(LCLObject);
|
|
|
|
|
|
Result := PGtkScrolledWindow(TGtkScrolledWindow.new(nil, nil));
|
|
Result^.show;
|
|
|
|
ListStore := gtk_list_store_new (2, [G_TYPE_STRING, G_TYPE_POINTER, nil]);
|
|
FCentralWidget := TGtkTreeView.new_with_model(PGtkTreeModel(ListStore));
|
|
PGtkTreeView(FCentralWidget)^.set_headers_visible(False);
|
|
g_object_unref (liststore);
|
|
|
|
ItemList := TGtkListStoreStringList.Create(PGtkListStore(PGtkTreeView(FCentralWidget)^.get_model), 0, LCLObject);
|
|
g_object_set_data(PGObject(FCentralWidget),GtkListItemLCLListTag, ItemList);
|
|
{if we use g_object_set_data_full then access violation occurs, so, revert to g_object_set_data}
|
|
// g_object_set_data_full(PGObject(FCentralWidget),GtkListItemLCLListTag, ItemList, @FreeStoreStringList);
|
|
|
|
Renderer := LCLIntfCellRenderer_New();
|
|
|
|
g_object_set_data(PGObject(renderer), 'lclwidget', Self);
|
|
|
|
AColumn := gtk_tree_view_column_new_with_attributes ('LISTITEMS', renderer,
|
|
['text', 0, nil]);
|
|
|
|
g_object_set_data(PGObject(AColumn), 'lclwidget', Self);
|
|
|
|
// maybe create GtkCellLayout class with our implementation and set that layout
|
|
// to AColumn
|
|
// PGtkCellLayout(AColumn)^.set_cell_data_func()
|
|
// PGtkCellLayout(AColumn)^.set_cell_data_func(renderer, @LCLIntfRenderer_GtkCellLayoutDataFunc, Self, nil);
|
|
AColumn^.set_cell_data_func(renderer, @LCLIntfRenderer_ColumnCellDataFunc, Self, nil);
|
|
|
|
PGtkTreeView(FCentralWidget)^.append_column(AColumn);
|
|
|
|
AColumn^.set_clickable(True);
|
|
|
|
// AColumn^set_cell_data_func(AColumn, renderer, @LCLIntfRenderer_ColumnCellDataFunc, Self, nil);
|
|
|
|
PGtkScrolledWindow(Result)^.add(FCentralWidget);
|
|
|
|
PGtkScrolledWindow(Result)^.get_vscrollbar^.set_can_focus(False);
|
|
PGtkScrolledWindow(Result)^.get_hscrollbar^.set_can_focus(False);
|
|
PGtkScrolledWindow(Result)^.set_policy(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
|
|
FListBoxStyle := AListBox.Style;
|
|
if FListBoxStyle <> lbOwnerDrawVariable then
|
|
begin
|
|
AColumn^.set_sizing(GTK_TREE_VIEW_COLUMN_FIXED);
|
|
PGtkTreeView(FCentralWidget)^.set_fixed_height_mode(True);
|
|
end;
|
|
|
|
end;
|
|
|
|
function TGtk3ListBox.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TGtk3ListBox.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
if not IsDesigning then
|
|
g_signal_connect_data(GetSelection, 'changed', TGCallback(@Gtk3ListBoxSelectionChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
function TGtk3ListBox.getHorizontalScrollbar: PGtkScrollbar;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result := PGtkScrollBar(PGtkScrolledWindow(Widget)^.get_hscrollbar);
|
|
end;
|
|
|
|
function TGtk3ListBox.getVerticalScrollbar: PGtkScrollbar;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result := PGtkScrollBar(PGtkScrolledWindow(Widget)^.get_vscrollbar);
|
|
end;
|
|
|
|
function TGtk3ListBox.GetScrolledWindow: PGtkScrolledWindow;
|
|
begin
|
|
if IsWidgetOK then
|
|
Result := PGtkScrolledWindow(Widget)
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
function TGtk3ListBox.GetItemIndex: Integer;
|
|
var
|
|
TreeView: PGtkTreeView;
|
|
Path: PGtkTreePath;
|
|
Column: PGtkTreeViewColumn;
|
|
Selection: PGtkTreeSelection;
|
|
begin
|
|
Result := -1;
|
|
if Gtk3IsWidget(FWidget) then
|
|
begin
|
|
Path := nil;
|
|
Column := nil;
|
|
TreeView := PGtkTreeView(GetContainerWidget);
|
|
TreeView^.get_cursor(@Path, @Column);
|
|
if Path <> nil then
|
|
begin
|
|
Result := gtk_tree_path_get_indices(Path)^;
|
|
if Result = 0 then
|
|
begin
|
|
Selection := TreeView^.get_selection;
|
|
if not Selection^.path_is_selected(Path) then
|
|
Result := -1;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ListBox.GetMultiSelect: Boolean;
|
|
var
|
|
Selection: PGtkTreeSelection;
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
Selection := GetSelection;
|
|
if Selection <> nil then
|
|
Result := Selection^.get_mode <> GTK_SELECTION_SINGLE;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListBox.SetItemIndex(AValue: Integer);
|
|
var
|
|
TreeView: PGtkTreeView;
|
|
Selection: PGtkTreeSelection;
|
|
Path: PGtkTreePath;
|
|
begin
|
|
if Gtk3IsWidget(FWidget) then
|
|
begin
|
|
TreeView := PGtkTreeView(GetContainerWidget);
|
|
Selection := GetSelection;
|
|
if (AValue < 0) then
|
|
Path := nil
|
|
else
|
|
Path := gtk_tree_path_new_from_indices(AValue, [-1]);
|
|
|
|
// if singleselection mode then selection = itemindex
|
|
if Path <> nil then
|
|
begin
|
|
gtk_tree_view_set_cursor(TreeView, Path, nil, False);
|
|
end else
|
|
begin
|
|
Path := gtk_tree_path_new_from_indices(0, [-1]);
|
|
gtk_tree_view_set_cursor(TreeView, Path, nil, False);
|
|
gtk_tree_selection_unselect_all(Selection);
|
|
end;
|
|
|
|
if Path <> nil then
|
|
gtk_tree_path_free(Path);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListBox.SetListBoxStyle(AValue: TListBoxStyle);
|
|
begin
|
|
if FListBoxStyle=AValue then Exit;
|
|
FListBoxStyle:=AValue;
|
|
end;
|
|
|
|
procedure TGtk3ListBox.SetMultiSelect(AValue: Boolean);
|
|
var
|
|
Selection: PGtkTreeSelection;
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
Selection := GetSelection;
|
|
if Selection <> nil then
|
|
begin
|
|
if AValue then
|
|
Selection^.set_mode(GTK_SELECTION_MULTIPLE)
|
|
else
|
|
Selection^.set_mode(GTK_SELECTION_SINGLE);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ListBox.GetSelCount: Integer;
|
|
var
|
|
Selection: PGtkTreeSelection;
|
|
Rows: PGList;
|
|
ListStoreModel: PGtkTreeModel;
|
|
begin
|
|
Result := 0;
|
|
if not Gtk3IsWidget(FWidget) then
|
|
exit;
|
|
Selection := GetSelection;
|
|
if Selection = nil then
|
|
exit;
|
|
Rows := Selection^.get_selected_rows(@ListStoreModel);
|
|
Result := g_list_length(Rows);
|
|
g_list_free(Rows);
|
|
end;
|
|
|
|
function TGtk3ListBox.GetSelection: PGtkTreeSelection;
|
|
begin
|
|
if not IsWidgetOk then
|
|
exit(nil);
|
|
Result := PGtkTreeView(GetContainerWidget)^.get_selection;
|
|
end;
|
|
|
|
function TGtk3ListBox.GetItemRect(const AIndex: integer): TRect;
|
|
var
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
AGdkRect: TGdkRectangle;
|
|
ACol: TGtkTreeViewColumn;
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
AModel := PGtkTreeView(getContainerWidget)^.model;
|
|
if AModel = nil then
|
|
exit;
|
|
if AModel^.iter_nth_child(@Iter, nil, AIndex) then
|
|
begin
|
|
ACol := gtk_tree_view_get_column(PGtkTreeView(getContainerWidget), 0)^;
|
|
gtk_tree_view_get_cell_area(PGtkTreeView(getContainerWidget), AModel^.get_path(@Iter), @ACol, @AGdkRect);
|
|
Result := RectFromGdkRect(AGdkRect);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ListBox.GetIndexAtXY(const X, Y: integer): integer;
|
|
var
|
|
Path: PGtkTreePath;
|
|
Column: PGtkTreeViewColumn;
|
|
CellX, CellY: Integer;
|
|
Indices: PInteger;
|
|
begin
|
|
Result := -1;
|
|
if gtk_tree_view_get_path_at_pos(PGtkTreeView(getContainerWidget), X, Y,
|
|
@Path, @Column, @CellX, @CellY) then
|
|
begin
|
|
Indices := gtk_tree_path_get_indices(Path);
|
|
if Assigned(Indices) then
|
|
Result := Indices^;
|
|
gtk_tree_path_free(Path);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ListBox.GetItemSelected(const AIndex: Integer): Boolean;
|
|
var
|
|
ASelection: PGtkTreeSelection;
|
|
AModel: PGtkTreeModel;
|
|
Item: TGtkTreeIter;
|
|
begin
|
|
Result := False;
|
|
|
|
if not IsWidgetOK then
|
|
exit;
|
|
|
|
AModel := PGtkTreeView(GetContainerWidget)^.model;
|
|
|
|
if AModel = nil then
|
|
exit;
|
|
|
|
ASelection := GetSelection;
|
|
|
|
if ASelection = nil then
|
|
exit;
|
|
|
|
if AModel^.iter_nth_child(@Item, nil, AIndex) then
|
|
Result := ASelection^.iter_is_selected(@Item);
|
|
end;
|
|
|
|
function TGtk3ListBox.GetScrollWidth: integer;
|
|
begin
|
|
Result := Round(getHorizontalScrollbar^.get_adjustment^.get_upper);
|
|
end;
|
|
|
|
procedure TGtk3ListBox.SelectItem(const AIndex: Integer; ASelected: Boolean);
|
|
var
|
|
ASelection: PGtkTreeSelection;
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
begin
|
|
if not IsWidgetOK then
|
|
exit;
|
|
|
|
AModel := PGtkTreeView(getContainerWidget)^.model;
|
|
|
|
if AModel = nil then
|
|
exit;
|
|
|
|
ASelection := GetSelection;
|
|
|
|
if AModel^.iter_nth_child(@Iter, nil, AIndex) then
|
|
begin
|
|
case ASelected of
|
|
True:
|
|
if not ASelection^.iter_is_selected(@Iter) then
|
|
ASelection^.select_iter(@Iter);
|
|
False:
|
|
if ASelection^.iter_is_selected(@Iter) then
|
|
ASelection^.unselect_iter(@Iter);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListBox.SetTopIndex(const AIndex: Integer);
|
|
var
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
APath: PGtkTreePath;
|
|
begin
|
|
AModel := PGtkTreeView(getContainerWidget)^.model;
|
|
|
|
if not AModel^.iter_nth_child(@Iter, nil, AIndex) then
|
|
exit;
|
|
APath := AModel^.get_path(@Iter);
|
|
PGtkTreeView(getContainerWidget)^.scroll_to_cell(APath, nil, False, 0.0, 0.0);
|
|
APath^.free;
|
|
end;
|
|
|
|
{ TGtk3CheckListBox }
|
|
|
|
procedure Gtk3WS_CheckListBoxDataFunc({%H-}tree_column: PGtkTreeViewColumn;
|
|
cell: PGtkCellRenderer; tree_model: PGtkTreeModel; iter: PGtkTreeIter; {%H-}data: Pointer); cdecl;
|
|
var
|
|
b: byte;
|
|
ADisabled: gboolean;
|
|
AValue: TCheckBoxState;
|
|
begin
|
|
B := 0;
|
|
ADisabled := False;
|
|
gtk_tree_model_get(tree_model, iter, [gtk3CLBState, @b, -1]);
|
|
gtk_tree_model_get(tree_model, iter, [gtk3CLBDisabled, @ADisabled, -1]);
|
|
AValue := TCheckBoxState(b); // TCheckBoxState is 4 byte
|
|
g_object_set(cell, 'inconsistent', [gboolean(AValue = cbGrayed), nil]);
|
|
if AValue <> cbGrayed then
|
|
gtk_cell_renderer_toggle_set_active(PGtkCellRendererToggle(cell), AValue = cbChecked);
|
|
|
|
g_object_set(cell, 'activatable', [gboolean(not ADisabled), nil]);
|
|
end;
|
|
|
|
procedure Gtk3WS_CheckListBoxToggle({%H-}cellrenderertoggle : PGtkCellRendererToggle;
|
|
arg1 : PGChar; AData: GPointer); cdecl;
|
|
var
|
|
Mess: TLMessage;
|
|
Param: PtrInt;
|
|
Iter : TGtkTreeIter;
|
|
TreeView: PGtkTreeView;
|
|
ListStore: PGtkTreeModel;
|
|
Path: PGtkTreePath;
|
|
AState: TCheckBoxState;
|
|
begin
|
|
Val(arg1, Param);
|
|
|
|
TreeView := PGtkTreeView(TGtk3CheckListBox(AData).GetContainerWidget);
|
|
ListStore := gtk_tree_view_get_model(TreeView);
|
|
if gtk_tree_model_iter_nth_child(ListStore, @Iter, nil, Param) then
|
|
begin
|
|
TCustomCheckListBox(TGtk3Widget(AData).LCLObject).Toggle(Param);
|
|
AState := TCustomCheckListBox(TGtk3Widget(AData).LCLObject).State[Param];
|
|
gtk_list_store_set(PGtkListStore(ListStore), @Iter, [gtk3CLBState,
|
|
Byte(AState), -1]);
|
|
end;
|
|
|
|
|
|
Path := gtk_tree_path_new_from_indices(Param, [-1]);
|
|
if Path <> nil then
|
|
begin
|
|
gtk_tree_view_set_cursor(TreeView, Path, nil, False);
|
|
gtk_tree_path_free(Path);
|
|
end;
|
|
|
|
FillChar(Mess{%H-}, SizeOf(Mess), #0);
|
|
Mess.Msg := LM_CHANGED;
|
|
|
|
Mess.Result := 0;
|
|
Mess.WParam := Param;
|
|
DeliverMessage(TGtk3Widget(AData).LCLObject, Mess);
|
|
|
|
end;
|
|
|
|
function TGtk3CheckListBox.CreateWidget(const Params: TCreateParams
|
|
): PGtkWidget;
|
|
var
|
|
ACheckListBox: TCustomCheckListBox;
|
|
ListStore: PGtkListStore;
|
|
ItemList: TGtkListStoreStringList;
|
|
AColumn: PGtkTreeViewColumn;
|
|
Toggle: PGtkCellRendererToggle;
|
|
Renderer : PGtkCellRenderer;
|
|
begin
|
|
FWidgetType := FWidgetType + [wtTreeModel, wtListBox, wtCheckListBox, wtScrollingWin];
|
|
ACheckListBox := TCustomCheckListBox(LCLObject);
|
|
FListBoxStyle := lbStandard;
|
|
|
|
Result := PGtkScrolledWindow(TGtkScrolledWindow.new(nil, nil));
|
|
Result^.show;
|
|
|
|
ListStore := gtk_list_store_new (4, [G_TYPE_UCHAR, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN, nil]);
|
|
FCentralWidget := TGtkTreeView.new_with_model(PGtkTreeModel(ListStore));
|
|
PGtkTreeView(FCentralWidget)^.set_headers_visible(False);
|
|
g_object_unref (liststore);
|
|
|
|
AColumn := gtk_tree_view_column_new;
|
|
|
|
// checkable column
|
|
Toggle := gtk_cell_renderer_toggle_new;
|
|
g_object_set_data(PGObject(Toggle), 'lclwidget', Self);
|
|
|
|
AColumn^.set_title('CHECKBINS');
|
|
AColumn^.pack_start(Toggle, True);
|
|
AColumn^.set_cell_data_func(Toggle, @Gtk3WS_CheckListBoxDataFunc, Self, nil);
|
|
Toggle^.set_active(True);
|
|
PGtkTreeView(FCentralWidget)^.append_column(AColumn);
|
|
AColumn^.set_clickable(True);
|
|
|
|
g_signal_connect_data(Toggle, 'toggled', TGCallback(@Gtk3WS_CheckListBoxToggle), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
Renderer := LCLIntfCellRenderer_New(); // gtk_cell_renderer_text_new;
|
|
|
|
g_object_set_data(PGObject(Renderer), 'lclwidget', Self);
|
|
|
|
AColumn := gtk_tree_view_column_new_with_attributes ('LISTITEMS', Renderer,
|
|
['text', 1, nil]);
|
|
|
|
g_object_set_data(PGObject(AColumn), 'lclwidget', Self);
|
|
|
|
// AColumn^.pack_start(Renderer, True);
|
|
|
|
AColumn^.set_cell_data_func(Renderer, @LCLIntfRenderer_ColumnCellDataFunc, Self, nil);
|
|
|
|
PGtkTreeView(FCentralWidget)^.append_column(AColumn);
|
|
|
|
ItemList := TGtkListStoreStringList.Create(PGtkListStore(PGtkTreeView(FCentralWidget)^.get_model), 1, LCLObject);
|
|
g_object_set_data(PGObject(FCentralWidget),GtkListItemLCLListTag, ItemList);
|
|
|
|
|
|
AColumn^.set_clickable(True);
|
|
|
|
// AColumn^set_cell_data_func(AColumn, renderer, @LCLIntfRenderer_ColumnCellDataFunc, Self, nil);
|
|
|
|
PGtkScrolledWindow(Result)^.add(FCentralWidget);
|
|
|
|
|
|
PGtkScrolledWindow(Result)^.get_vscrollbar^.set_can_focus(False);
|
|
PGtkScrolledWindow(Result)^.get_hscrollbar^.set_can_focus(False);
|
|
PGtkScrolledWindow(Result)^.set_policy(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
|
|
FListBoxStyle := ACheckListBox.Style;
|
|
if ACheckListBox.MultiSelect then
|
|
PGtkTreeView(FCentralWidget)^.get_selection^.set_mode(GTK_SELECTION_MULTIPLE)
|
|
else
|
|
PGtkTreeView(FCentralWidget)^.get_selection^.set_mode(GTK_SELECTION_SINGLE);
|
|
// AListBox.Style;
|
|
if FListBoxStyle <> lbOwnerDrawVariable then
|
|
begin
|
|
//AColumn^.set_sizing(GTK_TREE_VIEW_COLUMN_FIXED);
|
|
//PGtkTreeView(FCentralWidget)^.set_fixed_height_mode(True);
|
|
end;
|
|
|
|
end;
|
|
|
|
{ TGtk3ListView }
|
|
|
|
function Gtk3WS_ListViewItemPreSelected({%H-}selection: PGtkTreeSelection; {%H-}model: PGtkTreeModel;
|
|
path: PGtkTreePath; path_is_currently_selected: GBoolean; AData: GPointer): GBoolean; cdecl;
|
|
begin
|
|
if path_is_currently_selected then ;
|
|
// DebugLn('Gtk3WS_ListViewItemSelected ,path selected ',dbgs(path_is_currently_selected));
|
|
// this function is called *before* the item is selected
|
|
// The result should be True to allow the Item to change selection
|
|
Result := True;
|
|
|
|
if (AData = nil) or TGtk3Widget(AData).InUpdate then
|
|
exit;
|
|
|
|
if not Assigned(TGtk3ListView(AData).FPreselectedIndices) then
|
|
TGtk3ListView(AData).FPreselectedIndices := TFPList.Create;
|
|
|
|
if TGtk3ListView(AData).FPreselectedIndices.IndexOf({%H-}Pointer(PtrInt(gtk_tree_path_get_indices(path)^))) = -1 then
|
|
TGtk3ListView(AData).FPreselectedIndices.Add({%H-}Pointer(PtrInt(gtk_tree_path_get_indices(path)^)));
|
|
end;
|
|
|
|
procedure Gtk3WS_ListViewItemSelected(ASelection: PGtkTreeSelection; AData: GPointer); cdecl;
|
|
var
|
|
AList, TmpList: PGList;
|
|
Msg: TLMNotify;
|
|
NM: TNMListView;
|
|
Path: PGtkTreePath;
|
|
Indices: Integer;
|
|
i, j: Integer;
|
|
B: Boolean;
|
|
begin
|
|
if (AData = nil) or TGtk3Widget(AData).InUpdate then
|
|
exit;
|
|
if not Assigned(TGtk3ListView(AData).FPreselectedIndices) then
|
|
exit;
|
|
|
|
AList := gtk_tree_selection_get_selected_rows(ASelection, nil);
|
|
TGtk3Widget(AData).BeginUpdate; // Prevents entering Gtk3WS_ListViewItemPreSelected
|
|
|
|
try
|
|
for i := 0 to TGtk3ListView(AData).FPreselectedIndices.Count - 1 do
|
|
begin
|
|
FillChar(Msg{%H-}, SizeOf(Msg), 0);
|
|
Msg.Msg := CN_NOTIFY;
|
|
FillChar(NM{%H-}, SizeOf(NM), 0);
|
|
NM.hdr.hwndfrom := HWND(TGtk3Widget(AData));
|
|
NM.hdr.code := LVN_ITEMCHANGED;
|
|
NM.iItem := {%H-}PtrInt(TGtk3ListView(AData).FPreselectedIndices.Items[i]);
|
|
NM.iSubItem := 0;
|
|
B := False;
|
|
|
|
TmpList := AList;
|
|
while TmpList <> nil do
|
|
begin
|
|
Path := PGtkTreePath(TmpList^.data);
|
|
if Assigned(Path) then
|
|
begin
|
|
Indices := gtk_tree_path_get_indices(Path)^;
|
|
B := Indices = {%H-}PtrInt(TGtk3ListView(AData).FPreselectedIndices.Items[i]);
|
|
if B then
|
|
break;
|
|
end;
|
|
TmpList := TmpList^.next;
|
|
end;
|
|
|
|
if not B then
|
|
NM.uOldState := LVIS_SELECTED
|
|
else
|
|
NM.uNewState := LVIS_SELECTED;
|
|
NM.uChanged := LVIF_STATE;
|
|
Msg.NMHdr := @NM.hdr;
|
|
DeliverMessage(TGtk3Widget(AData).LCLObject, Msg);
|
|
end;
|
|
finally
|
|
FreeAndNil(TGtk3ListView(AData).FPreselectedIndices);
|
|
if AList <> nil then
|
|
begin
|
|
TmpList := AList;
|
|
while TmpList <> nil do
|
|
begin
|
|
Path := PGtkTreePath(TmpList^.data);
|
|
if Assigned(Path) then
|
|
gtk_tree_path_free(Path);
|
|
TmpList := TmpList^.next;
|
|
end;
|
|
g_list_free(AList);
|
|
end;
|
|
|
|
TGtk3Widget(AData).EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
type
|
|
TCustomListViewHack = class(TCustomListView);
|
|
|
|
procedure TGtk3ListView.setItemWidth(const AImageListWidth: integer);
|
|
var
|
|
aImgWidth, aBorders: gint;
|
|
AListView: TCustomListViewHack;
|
|
begin
|
|
aImgWidth := AImageListWidth;
|
|
aListView := TCustomListViewHack(LCLObject);
|
|
if not (AListView.ViewStyle in [vsSmallIcon, vsIcon]) then
|
|
exit;
|
|
if not Gtk3IsWidget(getContainerWidget) then
|
|
exit;
|
|
if aImgWidth <= 0 then
|
|
begin
|
|
if AListView.ViewStyle = vsIcon then
|
|
gtk_icon_size_lookup(Ord(GTK_ICON_SIZE_DIALOG), @aImgWidth, @aBorders)
|
|
else
|
|
gtk_icon_size_lookup(Ord(GTK_ICON_SIZE_LARGE_TOOLBAR), @aImgWidth, @aBorders);
|
|
end;
|
|
PGtkIconView(GetContainerWidget)^.set_item_width(aImgWidth);
|
|
end;
|
|
|
|
function TGtk3ListView.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AListView: TCustomListViewHack;
|
|
AScrollStyle: TGtkScrollStyle;
|
|
PtrType: GType;
|
|
TreeModel: PGtkTreeModel;
|
|
iter:TGtkTreeIter;
|
|
pxb:PGdkPixbuf;
|
|
err:gint;
|
|
begin
|
|
FImages := nil;
|
|
FPreselectedIndices := nil;
|
|
FWidgetType := FWidgetType + [wtTreeModel, wtListView, wtScrollingWin];
|
|
AListView := TCustomListViewHack(LCLObject);
|
|
Result := PGtkScrolledWindow(TGtkScrolledWindow.new(nil, nil));
|
|
|
|
PtrType := G_TYPE_POINTER;
|
|
|
|
if AListView.ViewStyle in [vsIcon,vsSmallIcon] then
|
|
begin
|
|
TreeModel := PGtkTreeModel(gtk_list_store_new(3, [
|
|
G_TYPE_POINTER, // ListItem pointer
|
|
G_TYPE_STRING, // text
|
|
gdk_pixbuf_get_type() // pixbuf
|
|
]));
|
|
FCentralWidget := TGtkIconView.new_with_model(TreeModel);
|
|
PGtkIconView(FCentralWidget)^.set_text_column(1);
|
|
PGtkIconView(FCentralWidget)^.set_pixbuf_column(2);
|
|
PGtkIconView(FCentralWidget)^.selection_mode:=GTK_SELECTION_SINGLE;
|
|
end
|
|
else
|
|
begin
|
|
TreeModel := PGtkTreeModel(gtk_list_store_newv(1, @PtrType));
|
|
FCentralWidget := TGtkTreeView.new_with_model(TreeModel);
|
|
end;
|
|
|
|
FIsTreeView := not (AListView.ViewStyle in [vsIcon,vsSmallIcon]);
|
|
|
|
FCentralWidget^.set_has_window(True);
|
|
FCentralWidget^.show;
|
|
|
|
PGtkScrolledWindow(Result)^.add(FCentralWidget);
|
|
//PGtkScrolledWindow(Result)^.set_focus_child(FCentralWidget);
|
|
|
|
AScrollStyle := Gtk3TranslateScrollStyle(AListView.ScrollBars);
|
|
// gtk3 scrolled window hates GTK_POLICY_NONE
|
|
PGtkScrolledWindow(Result)^.set_policy(AScrollStyle.Horizontal, AScrollStyle.Vertical);
|
|
PGtkScrolledWindow(Result)^.set_shadow_type(BorderStyleShadowMap[AListView.BorderStyle]);
|
|
PGtkScrolledWindow(Result)^.get_vscrollbar^.set_can_focus(False);
|
|
PGtkScrolledWindow(Result)^.get_hscrollbar^.set_can_focus(False);
|
|
g_object_unref (PGObject(TreeModel));
|
|
PGtkScrolledWindow(Result)^.set_can_focus(False);
|
|
PGtkTreeView(FCentralWidget)^.set_can_focus(True);
|
|
if FIsTreeView then
|
|
begin
|
|
gtk_tree_selection_set_select_function(PGtkTreeView(FCentralWidget)^.get_selection, TGtkTreeSelectionFunc(@Gtk3WS_ListViewItemPreSelected),
|
|
Self, nil);
|
|
g_signal_connect_data(PGtkTreeView(FCentralWidget)^.get_selection, 'changed', TGCallback(@Gtk3WS_ListViewItemSelected), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
PGtkTreeView(FCentralWidget)^.set_headers_visible(AListView.ShowColumnHeaders and (AListView.ViewStyle = vsReport));
|
|
PGtkTreeView(FCentralWidget)^.resize_children;
|
|
|
|
end else
|
|
begin
|
|
g_signal_connect_data (PGtkIconView(FCentralWidget), 'selection-changed',
|
|
TGCallback(@selection_changed), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
end;
|
|
|
|
class function TGtk3ListView.selection_changed(AIconView: PGtkIconView;
|
|
aData: gPointer): gboolean; cdecl;
|
|
var
|
|
pl, tmp: PGList;
|
|
pndx: PGint;
|
|
i, cnt: gint;
|
|
Msg: TLMNotify;
|
|
NM: TNMListView;
|
|
ctl: TGtk3ListView;
|
|
begin
|
|
Result := gtk_false;
|
|
ctl := TGtk3ListView(aData);
|
|
pl := PGtkIconView(ctl.GetContainerWidget)^.get_selected_items();
|
|
|
|
if Assigned(pl) then
|
|
begin
|
|
try
|
|
tmp := pl;
|
|
while Assigned(tmp) do
|
|
begin
|
|
pndx := PGtkTreePath(tmp^.data)^.get_indices_with_depth(@cnt);
|
|
// lv := TListView(ctl.LCLObject);
|
|
ctl.BeginUpdate;
|
|
try
|
|
for i := 0 to cnt - 1 do
|
|
begin
|
|
FillChar(Msg{%H-}, SizeOf(Msg), 0);
|
|
Msg.Msg := CN_NOTIFY;
|
|
FillChar(NM{%H-}, SizeOf(NM), 0);
|
|
NM.hdr.hwndfrom := HWND(ctl);
|
|
NM.hdr.code := LVN_ITEMCHANGED;
|
|
NM.iItem := {%H-}PtrInt(pndx^);
|
|
NM.iSubItem := 0;
|
|
NM.uNewState := LVIS_SELECTED;
|
|
NM.uChanged := LVIF_STATE;
|
|
Msg.NMHdr := @NM.hdr;
|
|
ctl.DeliverMessage(Msg);
|
|
inc(pndx);
|
|
end;
|
|
finally
|
|
ctl.EndUpdate;
|
|
end;
|
|
gtk_tree_path_free(PGtkTreePath(tmp^.data));
|
|
|
|
tmp := tmp^.next;
|
|
end;
|
|
finally
|
|
g_list_free(pl);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ListView.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TGtk3ListView.SetColor(AValue: TColor);
|
|
var
|
|
ADisabledColor, BgColor: TGdkRGBA;
|
|
begin
|
|
|
|
BgColor := TColortoTGdkRGBA(ColorToRgb(AValue));
|
|
|
|
getContainerWidget^.get_style_context^.get_background_color([GTK_STATE_FLAG_INSENSITIVE], @ADisabledColor);
|
|
//override all
|
|
if AValue = clDefault then
|
|
gtk_widget_override_background_color(getContainerWidget, GTK_STATE_FLAG_NORMAL, nil)
|
|
else
|
|
gtk_widget_override_background_color(getContainerWidget, GTK_STATE_FLAG_NORMAL, @BgColor);
|
|
//return system highlight color
|
|
BgColor := TColortoTGdkRGBA(ColorToRgb(clHighlight));
|
|
gtk_widget_override_background_color(getContainerWidget, [GTK_STATE_FLAG_SELECTED], @BgColor);
|
|
gtk_widget_override_background_color(getContainerWidget, [GTK_STATE_FLAG_INSENSITIVE], @ADisabledColor);
|
|
end;
|
|
|
|
destructor TGtk3ListView.Destroy;
|
|
begin
|
|
ClearImages;
|
|
FreeAndNil(FImages);
|
|
FreeAndNil(FPreselectedIndices);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
function TGtk3ListView.getHorizontalScrollbar: PGtkScrollbar;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result := PGtkScrollBar(PGtkScrolledWindow(Widget)^.get_hscrollbar);
|
|
end;
|
|
|
|
function TGtk3ListView.getVerticalScrollbar: PGtkScrollbar;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result := PGtkScrollBar(PGtkScrolledWindow(Widget)^.get_vscrollbar);
|
|
end;
|
|
|
|
function TGtk3ListView.GetScrolledWindow: PGtkScrolledWindow;
|
|
begin
|
|
if IsWidgetOK then
|
|
Result := PGtkScrolledWindow(Widget)
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ClearImages;
|
|
var
|
|
i: Integer;
|
|
begin
|
|
if Assigned(FImages) then
|
|
begin
|
|
for i := FImages.Count - 1 downto 0 do
|
|
if FImages[i] <> nil then
|
|
g_object_unref(FImages[i]);
|
|
FImages.Clear;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ColumnDelete(AIndex: Integer);
|
|
var
|
|
AColumn: PGtkTreeViewColumn;
|
|
begin
|
|
if IsWidgetOK and IsTreeView then
|
|
begin
|
|
AColumn := PGtkTreeView(GetContainerWidget)^.get_column(AIndex);
|
|
if (AColumn<>nil) then
|
|
PGtkTreeView(GetContainerWidget)^.remove_column(AColumn);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ListView.ColumnGetWidth(AIndex: Integer): Integer;
|
|
var
|
|
AColumn: PGtkTreeViewColumn;
|
|
begin
|
|
Result := 0;
|
|
if IsWidgetOK and IsTreeView then
|
|
begin
|
|
AColumn := PGtkTreeView(GetContainerWidget)^.get_column(AIndex);
|
|
if (AColumn<>nil) then
|
|
Result := AColumn^.get_width;
|
|
end;
|
|
end;
|
|
|
|
procedure Gtk3WSLV_ListViewGetPixbufDataFuncForColumn(tree_column: PGtkTreeViewColumn;
|
|
{%H-}cell: PGtkCellRenderer; tree_model: PGtkTreeModel; iter: PGtkTreeIter; AData: GPointer); cdecl;
|
|
var
|
|
ListItem: TListItem;
|
|
Images: TFPList;
|
|
// Widgets: PTVWidgets;
|
|
ListColumn: TListColumn;
|
|
ImageIndex: Integer;
|
|
ColumnIndex: Integer;
|
|
APath: PGtkTreePath;
|
|
gv:TGValue;
|
|
pb:PgdkPixbuf;
|
|
begin
|
|
fillchar(gv,sizeof(gv),0);
|
|
gv.init(G_TYPE_OBJECT);
|
|
gv.set_instance(nil);
|
|
PGtkCellRendererPixbuf(cell)^.set_property('pixbuf',@gv);
|
|
|
|
gtk_tree_model_get(tree_model, iter, [0, @ListItem, -1]);
|
|
|
|
ListColumn := TListColumn(g_object_get_data(tree_column, 'TListColumn'));
|
|
if ListColumn = nil then
|
|
Exit;
|
|
ColumnIndex := ListColumn.Index;
|
|
Images := TGtk3ListView(AData).Images;
|
|
if Images = nil then
|
|
Exit;
|
|
ImageIndex := -1;
|
|
|
|
if (ListItem = nil) and TCustomListView(TGtk3Widget(AData).LCLObject).OwnerData then
|
|
begin
|
|
APath := gtk_tree_model_get_path(tree_model,iter);
|
|
ListItem := TCustomListView(TGtk3Widget(AData).LCLObject).Items[gtk_tree_path_get_indices(APath)^];
|
|
gtk_tree_path_free(APath);
|
|
end;
|
|
|
|
if ListItem = nil then
|
|
Exit;
|
|
|
|
if ColumnIndex = 0 then
|
|
ImageIndex := ListItem.ImageIndex
|
|
else
|
|
if ColumnIndex -1 <= ListItem.SubItems.Count-1 then
|
|
ImageIndex := ListItem.SubItemImages[ColumnIndex-1];
|
|
|
|
if (ImageIndex > -1) and (ImageIndex <= Images.Count-1) then
|
|
pb:=TGtk3Image(TBitmap(Images.Items[ImageIndex]).Handle).Handle^.copy
|
|
else
|
|
pb:=nil;
|
|
|
|
gv.set_instance(pb);
|
|
PGtkCellRendererPixbuf(cell)^.set_property('pixbuf',@gv);
|
|
|
|
if Assigned(pb) then
|
|
g_object_unref(pb);
|
|
end;
|
|
|
|
procedure Gtk3WS_ListViewColumnClicked(column: PGtkTreeViewColumn; AData: GPointer); cdecl;
|
|
var
|
|
AColumn: TListColumn;
|
|
Msg: TLMNotify;
|
|
NM: TNMListView;
|
|
begin
|
|
AColumn := TListColumn(g_object_get_data(PGObject(column), 'TListColumn'));
|
|
|
|
if (AColumn = nil) or (AData = nil) then
|
|
exit;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), 0);
|
|
Msg.Msg := CN_NOTIFY;
|
|
|
|
FillChar(NM{%H-}, SizeOf(NM), 0);
|
|
NM.hdr.hwndfrom := {%H-}PtrUInt(AData);
|
|
NM.hdr.code := LVN_COLUMNCLICK;
|
|
NM.iItem := -1;
|
|
NM.iSubItem := AColumn.Index;
|
|
Msg.NMHdr := @NM.hdr;
|
|
DeliverMessage(TGtk3Widget(AData).LCLObject, Msg);
|
|
end;
|
|
|
|
procedure TGtk3ListView.ColumnInsert(AIndex: Integer; AColumn: TListColumn);
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
PixRenderer,
|
|
TextRenderer: PGtkCellRenderer;
|
|
begin
|
|
if not IsWidgetOK or not IsTreeView then
|
|
exit;
|
|
AGtkColumn := TGtkTreeViewColumn.new;
|
|
|
|
PixRenderer := gtk_cell_renderer_pixbuf_new();
|
|
TextRenderer := LCLIntfCellRenderer_New;
|
|
|
|
AGtkColumn^.pack_start(PixRenderer, False);
|
|
AGtkColumn^.pack_start(TextRenderer, True);
|
|
|
|
// gtk_tree_view_column_set_cell_data_func(column, pixrenderer, TGtkTreeCellDataFunc(@Gtk2WSLV_ListViewGetPixbufDataFuncForColumn), WidgetInfo, nil);
|
|
// gtk_tree_view_column_set_cell_data_func(column, textrenderer, TGtkTreeCellDataFunc(@LCLIntfCellRenderer_CellDataFunc), Self, nil);
|
|
AGtkColumn^.set_cell_data_func(PixRenderer, @Gtk3WSLV_ListViewGetPixbufDataFuncForColumn, Self, nil);
|
|
|
|
|
|
AGtkColumn^.set_cell_data_func(PGtkCellRenderer(TextRenderer), TGtkTreeCellDataFunc(@LCLIntfCellRenderer_CellDataFunc), Self, nil);
|
|
|
|
//store the TColumn in the column data for callbacks
|
|
g_object_set_data(AGtkColumn, PgChar('TListColumn'), gpointer(AColumn));
|
|
|
|
g_object_set_data(AGtkColumn, 'pix_renderer', PixRenderer);
|
|
g_object_set_data(AGtkColumn, 'text_renderer', TextRenderer);
|
|
|
|
g_signal_connect_data(AGtkColumn,'clicked', TGCallback(@Gtk3WS_ListViewColumnClicked), Self, nil, G_CONNECT_DEFAULT);
|
|
PGtkTreeView(GetContainerWidget)^.insert_column(AGtkColumn, AIndex);
|
|
AGtkColumn^.set_clickable(True);
|
|
|
|
end;
|
|
|
|
procedure TGtk3ListView.SetAlignment(AIndex: Integer; AColumn: TListColumn;
|
|
AAlignment: TAlignment);
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
AFloat: Double;
|
|
AList: PGList;
|
|
textrenderer: PGtkCellRenderer;
|
|
Value: TGValue;
|
|
begin
|
|
if not IsWidgetOK or not IsTreeView then
|
|
exit;
|
|
AGtkColumn := PGtkTreeView(getContainerWidget)^.get_column(AIndex);
|
|
if AGtkColumn = nil then
|
|
exit;
|
|
|
|
case AAlignment of
|
|
taRightJustify: AFloat := 1;
|
|
taCenter: AFloat := 0.5;
|
|
else
|
|
AFloat := 0;
|
|
end;
|
|
|
|
|
|
AList := PGtkCellLayout(AGtkColumn)^.get_cells;
|
|
// AList := gtk_tree_view_column_get_cell_renderers(AColumn);
|
|
textrenderer := PGtkCellRenderer(g_list_last(AList)^.data);
|
|
g_list_free(AList);
|
|
|
|
Value.g_type := G_TYPE_FLOAT;
|
|
Value.set_float(AFloat);
|
|
g_object_set_property(textrenderer, PChar('xalign'), @Value);
|
|
|
|
{now we call set alignment because it calls update over visible rows in col}
|
|
AGtkColumn^.set_alignment(AFloat);
|
|
end;
|
|
|
|
procedure TGtk3ListView.SetColumnAutoSize(AIndex: Integer;
|
|
AColumn: TListColumn; AAutoSize: Boolean);
|
|
const
|
|
SizingMap: array[Boolean] of TGtkTreeViewColumnSizing = (
|
|
GTK_TREE_VIEW_COLUMN_FIXED {2},
|
|
GTK_TREE_VIEW_COLUMN_AUTOSIZE {1}
|
|
);
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
begin
|
|
if not IsWidgetOK or not IsTreeView then
|
|
exit;
|
|
AGtkColumn := PGtkTreeView(getContainerWidget)^.get_column(AIndex);
|
|
if AGtkColumn <> nil then
|
|
begin
|
|
AGtkColumn^.set_resizable(True);
|
|
AGtkColumn^.set_sizing(SizingMap[AAutoSize]);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.SetColumnCaption(AIndex: Integer; AColumn: TListColumn;
|
|
const ACaption: String);
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
begin
|
|
if not IsWidgetOK or not IsTreeView then
|
|
exit;
|
|
AGtkColumn := PGtkTreeView(getContainerWidget)^.get_column(AIndex);
|
|
if AGtkColumn <> nil then
|
|
begin
|
|
AGtkColumn^.set_title(PgChar(ACaption));
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.SetColumnMaxWidth(AIndex: Integer;
|
|
AColumn: TListColumn; AMaxWidth: Integer);
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
begin
|
|
if not IsWidgetOK or not IsTreeView then
|
|
exit;
|
|
AGtkColumn := PGtkTreeView(getContainerWidget)^.get_column(AIndex);
|
|
if AGtkColumn <> nil then
|
|
begin
|
|
if AMaxWidth <= 0 then
|
|
AGtkColumn^.set_max_width(10000)
|
|
else
|
|
AGtkColumn^.set_max_width(AMaxWidth);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.SetColumnMinWidth(AIndex: Integer;
|
|
AColumn: TListColumn; AMinWidth: Integer);
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
begin
|
|
if not IsWidgetOK or not IsTreeView then
|
|
exit;
|
|
AGtkColumn := PGtkTreeView(getContainerWidget)^.get_column(AIndex);
|
|
if AGtkColumn <> nil then
|
|
AGtkColumn^.set_min_width(AMinWidth);
|
|
end;
|
|
|
|
procedure TGtk3ListView.SetColumnWidth(AIndex: Integer; AColumn: TListColumn;
|
|
AWidth: Integer);
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
begin
|
|
if not IsWidgetOK or not IsTreeView then
|
|
exit;
|
|
AGtkColumn := PGtkTreeView(getContainerWidget)^.get_column(AIndex);
|
|
if AGtkColumn <> nil then
|
|
begin
|
|
AGtkColumn^.set_fixed_width(AWidth + Ord(AWidth < 1));
|
|
end;
|
|
// AGtkColumn^.set_widget();
|
|
end;
|
|
|
|
procedure TGtk3ListView.SetColumnVisible(AIndex: Integer; AColumn: TListColumn;
|
|
AVisible: Boolean);
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
begin
|
|
if not IsWidgetOK or not IsTreeView then
|
|
exit;
|
|
AGtkColumn := PGtkTreeView(getContainerWidget)^.get_column(AIndex);
|
|
if AGtkColumn <> nil then
|
|
begin
|
|
AGtkColumn^.set_visible(AVisible and (TListView(LCLObject).ViewStyle in [vsList, vsReport]));
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ColumnSetSortIndicator(const AIndex: Integer;
|
|
const AColumn: TListColumn; const ASortIndicator: TSortIndicator);
|
|
const
|
|
GtkOrder : array [ TSortIndicator] of TGtkSortType = (GTK_SORT_ASCENDING {0}, GTK_SORT_ASCENDING {0}, GTK_SORT_DESCENDING {1});
|
|
var
|
|
AGtkColumn: PGtkTreeViewColumn;
|
|
begin
|
|
AGtkColumn := PGtkTreeView(getContainerWidget)^.get_column(AIndex);
|
|
|
|
if AGtkColumn <> nil then
|
|
begin
|
|
if ASortIndicator = siNone then
|
|
AGtkColumn^.set_sort_indicator(false)
|
|
else
|
|
begin
|
|
AGtkColumn^.set_sort_indicator(true);
|
|
AgtkColumn^.set_sort_order(GtkOrder[ASortIndicator]);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ItemDelete(AIndex: Integer);
|
|
var
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
begin
|
|
if IsTreeView then
|
|
AModel := PGtkTreeView(getContainerWidget)^.get_model
|
|
else
|
|
AModel := PGtkIconView(getContainerWidget)^.get_model;
|
|
if gtk_tree_model_iter_nth_child(AModel, @Iter, nil, AIndex) then
|
|
gtk_list_store_remove(PGtkListStore(AModel), @Iter);
|
|
end;
|
|
|
|
function TGtk3ListView.ItemDisplayRect(AIndex: Integer; ASubItem: integer;
|
|
ACode: TDisplayCode): TRect;
|
|
var
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
Column: PGtkTreeViewColumn;
|
|
Path: PGtkTreePath;
|
|
ItemRect: TGdkRectangle;
|
|
cell: PGtkCellRenderer;
|
|
y, x: gint;
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
if IsTreeView then
|
|
AModel := PGtkTreeView(getContainerWidget)^.get_model
|
|
else
|
|
AModel := PGtkIconView(getContainerWidget)^.get_model;
|
|
Path := gtk_tree_path_new_from_indices(AIndex, [-1]);
|
|
try
|
|
if Self.IsTreeView then
|
|
begin
|
|
Column := gtk_tree_view_get_column(PGtkTreeView(GetContainerWidget), ASubItem);
|
|
gtk_tree_view_get_cell_area(PGtkTreeView(GetContainerWidget), Path, Column, @ItemRect);
|
|
end else
|
|
gtk_icon_view_get_cell_rect(PGtkIconView(getContainerWidget), Path, nil, @ItemRect);
|
|
Result := RectFromGdkRect(ItemRect);
|
|
finally
|
|
gtk_tree_path_free(Path);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ItemInsert(AIndex: Integer; AItem: TListItem);
|
|
var
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
NewIndex: Integer;
|
|
bmp:TBitmap;
|
|
pxb:PGdkPixbuf;
|
|
w,h: gint;
|
|
begin
|
|
if not IsWidgetOK then
|
|
exit;
|
|
if IsTreeView then
|
|
AModel := PGtkTreeView(getContainerWidget)^.get_model
|
|
else
|
|
AModel := PGtkIconView(getContainerWidget)^.get_model;
|
|
|
|
if AIndex = -1 then
|
|
NewIndex := AModel^.iter_n_children(nil)
|
|
else
|
|
NewIndex := AIndex;
|
|
|
|
if IsTreeView then
|
|
gtk_list_store_insert_with_values(PGtkListStore(AModel), @Iter, NewIndex,
|
|
[0, Pointer(AItem), -1])
|
|
else
|
|
begin
|
|
bmp:=TBitmap.Create;
|
|
if Assigned(TListView(LCLObject).LargeImages) then
|
|
TListView(LCLObject).LargeImages.GetBitmap(AIndex,bmp)
|
|
else
|
|
begin
|
|
gtk_icon_size_lookup(Ord(GTK_ICON_SIZE_LARGE_TOOLBAR), @w, @h);
|
|
bmp.SetSize(w, h);
|
|
end;
|
|
pxb:=TGtk3Image(bmp.Handle).Handle^.copy;
|
|
gtk_list_store_insert_with_values(PGtkListStore(AModel), @Iter, NewIndex,
|
|
[0, Pointer(AItem),
|
|
1, PChar(AItem.Caption),
|
|
2, pxb, -1] );
|
|
// list_store takes ownership, so unref and ref again.
|
|
g_object_unref(pxb);
|
|
if not Assigned(FImages) then
|
|
FImages := TFPList.Create;
|
|
g_object_ref(pxb);
|
|
FImages.Add(pxb);
|
|
bmp.Free;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ListView.ItemPosition(AIndex: integer): TPoint;
|
|
var
|
|
x, y: gint;
|
|
begin
|
|
Result := ItemDisplayRect(AIndex, 0, drBounds).TopLeft;
|
|
if IsTreeView then
|
|
begin
|
|
gtk_tree_view_convert_bin_window_to_widget_coords(
|
|
PGtkTreeView(GetContainerWidget),
|
|
Result.x, Result.y, @x, @y);
|
|
Result.x := x;
|
|
Result.y := y;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.UpdateItem(AIndex:integer;AItem: TListItem);
|
|
var
|
|
Path: PGtkTreePath;
|
|
ItemRect: TGdkRectangle;
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
bmp:TBitmap;
|
|
pxb:PGdkPixbuf;
|
|
w,h: gint;
|
|
begin
|
|
if IsTreeView then
|
|
begin
|
|
Path := gtk_tree_path_new_from_indices(AIndex, [-1]);
|
|
PGtkTreeView(GetContainerWidget)^.get_cell_area(Path, nil, @ItemRect);
|
|
gtk_tree_path_free(Path);
|
|
end else
|
|
begin
|
|
Path := gtk_tree_path_new_from_indices(AIndex, [-1]);
|
|
AModel:=PGtkIconView(GetContainerWidget)^.get_model;
|
|
AModel^.get_iter(@iter,path);
|
|
|
|
bmp := TBitmap.Create;
|
|
if (TCustomListViewHack(LCLObject).ViewStyle = vsIcon) and Assigned(TCustomListViewHack(LCLObject).LargeImages) then
|
|
TCustomListViewHack(LCLObject).LargeImages.GetBitmap(AItem.ImageIndex, bmp)
|
|
else
|
|
if (TCustomListViewHack(LCLObject).ViewStyle = vsSmallIcon) and Assigned(TCustomListViewHack(LCLObject).SmallImages) then
|
|
TCustomListViewHack(LCLObject).SmallImages.GetBitmap(AItem.ImageIndex, bmp)
|
|
else
|
|
begin
|
|
gtk_icon_size_lookup(Ord(GTK_ICON_SIZE_LARGE_TOOLBAR), @w, @h);
|
|
bmp.SetSize(w, h);
|
|
end;
|
|
pxb := TGtk3Image(Bmp.Handle).Handle^.copy;
|
|
gtk_list_store_set(PGtkListStore(AModel), @Iter,
|
|
[0, Pointer(AItem),
|
|
1, PChar(AItem.Caption),
|
|
2, pxb, -1] );
|
|
g_object_unref(pxb);
|
|
if not Assigned(FImages) then
|
|
FImages := TFPList.Create;
|
|
g_object_ref(pxb);
|
|
FImages.Add(pxb);
|
|
gtk_tree_path_free(Path);
|
|
bmp.Free;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ItemSetText(AIndex, ASubIndex: Integer;
|
|
AItem: TListItem; const AText: String);
|
|
var
|
|
Path: PGtkTreePath;
|
|
ItemRect: TGdkRectangle;
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
begin
|
|
if not IsWidgetOK then
|
|
exit;
|
|
|
|
if IsTreeView then
|
|
begin
|
|
Path := gtk_tree_path_new_from_indices(AIndex, [-1]);
|
|
if GetContainerWidget^.get_realized then
|
|
begin
|
|
PGtkTreeView(GetContainerWidget)^.get_cell_area(Path, nil, @ItemRect);
|
|
// here may be optimization
|
|
end;
|
|
gtk_tree_path_free(Path);
|
|
end else
|
|
begin
|
|
UpdateItem(AIndex,AItem);
|
|
end;
|
|
if GetContainerWidget^.get_visible and (ItemRect.height <> 0) then // item is visible
|
|
GetContainerWidget^.queue_draw;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ItemSetImage(AIndex, ASubIndex: Integer; AItem: TListItem);
|
|
var
|
|
Path: PGtkTreePath;
|
|
ItemRect: TGdkRectangle;
|
|
AModel: PGtkTreeModel;
|
|
Iter: TGtkTreeIter;
|
|
begin
|
|
if not IsWidgetOK then
|
|
exit;
|
|
|
|
if IsTreeView then
|
|
begin
|
|
Path := gtk_tree_path_new_from_indices(AIndex, [-1]);
|
|
if GetContainerWidget^.get_realized then
|
|
begin
|
|
PGtkTreeView(GetContainerWidget)^.get_cell_area(Path, nil, @ItemRect);
|
|
// here may be optimization
|
|
end;
|
|
gtk_tree_path_free(Path);
|
|
end else
|
|
begin
|
|
UpdateItem(AIndex,AItem);
|
|
end;
|
|
if GetContainerWidget^.get_visible and (ItemRect.height <> 0) then // item is visible
|
|
GetContainerWidget^.queue_draw;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ItemSetState(const AIndex: Integer;
|
|
const AItem: TListItem; const AState: TListItemState; const AIsSet: Boolean);
|
|
var
|
|
Path: PGtkTreePath;
|
|
ATreeSelection: PGtkTreeSelection;
|
|
begin
|
|
if not IsWidgetOK then
|
|
exit;
|
|
|
|
case AState of
|
|
lisCut,
|
|
lisDropTarget:
|
|
begin
|
|
//TODO: do something with the rowcolor ?
|
|
end;
|
|
|
|
lisFocused:
|
|
begin
|
|
Path := gtk_tree_path_new_from_string(PgChar(IntToStr(AIndex)));
|
|
if IsTreeView then
|
|
begin
|
|
if AIsSet then
|
|
PGtkTreeView(getContainerWidget)^.set_cursor(Path, nil, False)
|
|
else
|
|
PGtkTreeView(GetContainerWidget)^.set_cursor(Path, nil, False);
|
|
end else
|
|
begin
|
|
PGtkIconView(GetContainerWidget)^.set_cursor(Path, nil, False); // valgrind says leak
|
|
end;
|
|
if Path <> nil then
|
|
gtk_tree_path_free(Path);
|
|
end;
|
|
|
|
lisSelected:
|
|
begin
|
|
Path := gtk_tree_path_new_from_string(PgChar(IntToStr(AIndex)));
|
|
if IsTreeView then
|
|
begin
|
|
ATreeSelection := PGtkTreeView(GetContainerWidget)^.get_selection;
|
|
if AIsSet and not ATreeSelection^.path_is_selected(Path) then
|
|
begin
|
|
ATreeSelection^.select_path(Path);
|
|
// BroadcastMsg := True;
|
|
end else
|
|
if not AIsSet and ATreeSelection^.path_is_selected(Path) then
|
|
begin
|
|
ATreeSelection^.unselect_path(Path);
|
|
// BroadcastMsg := True;
|
|
end;
|
|
end else
|
|
begin
|
|
if AIsSet and not PGtkIconView(GetContainerWidget)^.path_is_selected(Path) then
|
|
begin
|
|
PGtkIconView(GetContainerWidget)^.select_path(Path);
|
|
// BroadCastMsg := True;
|
|
end else
|
|
if not AIsSet and PGtkIconView(GetContainerWidget)^.path_is_selected(Path) then
|
|
begin
|
|
PGtkIconView(GetContainerWidget)^.unselect_path(Path);
|
|
// BroadCastMsg := True;
|
|
end;
|
|
end;
|
|
if Path <> nil then
|
|
gtk_tree_path_free(Path);
|
|
// if BroadcastMsg then
|
|
// BroadCastListSelection(ALV, {%H-}PtrUInt(MainView), AIndex, not AIsSet);
|
|
end;
|
|
end;
|
|
|
|
end;
|
|
|
|
function TGtk3ListView.ItemGetState(const AIndex: Integer;
|
|
const AItem: TListItem; const AState: TListItemState; out AIsSet: Boolean
|
|
): Boolean;
|
|
var
|
|
Path: PGtkTreePath;
|
|
Column: PPGtkTreeViewColumn;
|
|
Cell: PPGtkCellRenderer;
|
|
APath: PGtkTreePath;
|
|
AStr: PChar;
|
|
begin
|
|
Result := False;
|
|
AIsSet := False;
|
|
if not IsWidgetOK then
|
|
exit;
|
|
case AState of
|
|
lisCut,
|
|
lisDropTarget:
|
|
begin
|
|
//TODO: do something with the rowcolor ?
|
|
end;
|
|
lisFocused:
|
|
begin
|
|
Path := nil;
|
|
Column := nil;
|
|
Cell := nil;
|
|
if IsTreeView then
|
|
PGtkTreeView(GetContainerWidget)^.get_cursor(@Path, Column)
|
|
else
|
|
PGtkIconView(GetContainerWidget)^.get_cursor(@Path, Cell);
|
|
if Assigned(Path) then
|
|
begin
|
|
AStr := gtk_tree_path_to_string(Path);
|
|
AIsSet := (StrToIntDef(AStr,-1) = AIndex);
|
|
if AStr <> nil then
|
|
g_free(AStr);
|
|
gtk_tree_path_free(Path);
|
|
Result := True;
|
|
end;
|
|
end;
|
|
|
|
lisSelected:
|
|
begin
|
|
APath := gtk_tree_path_new_from_string(PChar(IntToStr(AIndex)));
|
|
if IsTreeView then
|
|
AIsSet := PGtkTreeView(GetContainerWidget)^.get_selection^.path_is_selected(APath)
|
|
else
|
|
AIsSet := PGtkIconView(GetContainerWidget)^.path_is_selected(APath);
|
|
|
|
if APath <> nil then
|
|
gtk_tree_path_free(APath);
|
|
Result := True;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ListView.ScrollToRow(const ARow: integer);
|
|
var
|
|
ATreePath: PGtkTreePath;
|
|
begin
|
|
ATreePath := gtk_tree_path_new_from_indices(ARow, [-1]);
|
|
if IsTreeView then
|
|
gtk_tree_view_scroll_to_cell(PGtkTreeView(getContainerWidget), ATreePath, nil, False, 0.0, 0.0)
|
|
else
|
|
gtk_icon_view_scroll_to_path(PGtkIconView(getContainerWidget), ATreePath, False, 0.0, 0.0);
|
|
gtk_tree_path_free(ATreePath);
|
|
end;
|
|
|
|
procedure TGtk3ListView.UpdateImageCellsSize;
|
|
begin
|
|
// must get renderer via property
|
|
// gtk_tree_view_column_get_cell_renderers
|
|
end;
|
|
|
|
{ TGtk3ComboBox }
|
|
|
|
function TGtk3ComboBox.GetItemIndex: Integer;
|
|
begin
|
|
Result := -1;
|
|
if Assigned(FWidget) and Gtk3IsComboBox(Widget) then
|
|
Result := PGtkComboBox(Widget)^.get_active;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.SetDroppedDown(AValue: boolean);
|
|
begin
|
|
if Assigned(FWidget) and Gtk3IsComboBox(Widget) then
|
|
begin
|
|
if AValue then
|
|
PGtkComboBox(Widget)^.popup
|
|
else
|
|
PGtkComboBox(Widget)^.popdown;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.SetItemIndex(AValue: Integer);
|
|
begin
|
|
if IsWidgetOK and Gtk3IsComboBox(Widget) then
|
|
PGtkComboBox(Widget)^.set_active(AValue);
|
|
end;
|
|
|
|
function TGtk3ComboBox.GetCellView: PGtkCellView;
|
|
var
|
|
AList: PGList;
|
|
i: Integer;
|
|
begin
|
|
if FCellView = nil then
|
|
begin
|
|
AList := PGtkComboBox(Widget)^.get_children;
|
|
for i := 0 to g_list_length(AList) -1 do
|
|
begin
|
|
if Gtk3IsCellView(g_list_nth(AList, i)^.data) then
|
|
begin
|
|
FCellView := PGtkCellView(g_list_first(AList)^.data);
|
|
break;
|
|
end;
|
|
end;
|
|
g_list_free(AList);
|
|
end;
|
|
Result := FCellView;
|
|
end;
|
|
|
|
function TGtk3ComboBox.GetPopupWidget: PGtkWidget;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
if PGtkComboBox(Widget)^.priv3^.popup_widget <> nil then
|
|
Result := PGtkComboBox(Widget)^.priv3^.popup_widget
|
|
else
|
|
if PGtkComboBox(Widget)^.priv3^.tree_view <> nil then
|
|
Result := PGtkComboBox(Widget)^.priv3^.tree_view;
|
|
end;
|
|
|
|
function TGtk3ComboBox.GetButtonWidget: PGtkWidget;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
// button is of type GtkToggleButton
|
|
if PGtkComboBox(Widget)^.priv3^.button <> nil then
|
|
Result := PGtkComboBox(Widget)^.priv3^.button;
|
|
end;
|
|
|
|
function TGtk3ComboBox.GetArrowWidget: PGtkWidget;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
// arrow is type is GtkIcon
|
|
if PGtkComboBox(Widget)^.priv3^.arrow <> nil then
|
|
Result := PGtkComboBox(Widget)^.priv3^.arrow;
|
|
end;
|
|
|
|
function TGtk3ComboBox.getSelStart: integer;
|
|
var
|
|
AStartPos, AEndPos: gint;
|
|
begin
|
|
Result := 0;
|
|
if PGtkComboBox(Widget)^.has_entry then
|
|
begin
|
|
PGtkEditable(PGtkComboBox(Widget)^.get_child)^.get_selection_bounds(@AStartPos, @AEndPos);
|
|
Result := AStartPos;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ComboBox.getSelLength: integer;
|
|
var
|
|
AStartPos, AEndPos: gint;
|
|
begin
|
|
Result := 0;
|
|
if PGtkComboBox(Widget)^.has_entry then
|
|
begin
|
|
if PGtkEditable(PGtkComboBox(Widget)^.get_child)^.get_selection_bounds(@AStartPos, @AEndPos) then
|
|
Result := AEndPos - AStartPos;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ComboBox.getMaxLength: integer;
|
|
begin
|
|
Result := 0;
|
|
if PGtkComboBox(Widget)^.has_entry then
|
|
Result := PGtkEntry(PGtkComboBox(Widget)^.get_child)^.get_max_length;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.SetMaxLength(const AMaxLength: integer);
|
|
begin
|
|
if PGtkComboBox(Widget)^.has_entry then
|
|
begin
|
|
PGtkEntry(PGtkComboBox(Widget)^.get_child)^.set_max_length(AMaxLength);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.SetSelStart(const ANewStart: integer);
|
|
var
|
|
AStartPos, AEndPos: gint;
|
|
begin
|
|
if PGtkComboBox(Widget)^.has_entry then
|
|
begin
|
|
//PGtkEditable(PGtkComboBox(Widget)^.get_child)^.get_selection_bounds(@AStartPos, @AEndPos);
|
|
//if AEndPos < ANewStart then
|
|
// AEndPos := ANewStart;
|
|
AStartPos := ANewStart;
|
|
AEndPos := AStartPos + 1;
|
|
PGtkEditable(PGtkComboBox(Widget)^.get_child)^.select_region(AStartPos, AEndPos);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.SetSelLength(const ANewLength: integer);
|
|
var
|
|
AStartPos, AEndPos: gint;
|
|
begin
|
|
if PGtkEditable(PGtkComboBox(Widget)^.get_child)^.get_selection_bounds(@AStartPos, @AEndPos) then
|
|
begin
|
|
PGtkEditable(PGtkComboBox(Widget)^.get_child)^.select_region(AStartPos, AStartPos + ANewLength);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ComboBox.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
ACombo: TCustomComboBox;
|
|
ListStore: PGtkListStore;
|
|
ItemList: TGtkListStoreStringList;
|
|
Renderer: PGtkCellRenderer;
|
|
bs: string;
|
|
pos: gint;
|
|
begin
|
|
FWidgetType := FWidgetType + [wtTreeModel, wtComboBox];
|
|
ACombo := TCustomComboBox(LCLObject);
|
|
ListStore := gtk_list_store_new (2, [G_TYPE_STRING, G_TYPE_POINTER, nil]);
|
|
// LCLGtkComboBox is introduced because of inability to control width and height
|
|
// of control.
|
|
if ACombo.Style.HasEditBox then
|
|
Result := LCLGtkComboBoxNewWithModelAndEntry(PGtkTreeModel(ListStore))
|
|
else
|
|
Result := LCLGtkComboBoxNewWithModel(PGtkTreeModel(ListStore));
|
|
|
|
if ACombo.Style.HasEditBox then
|
|
begin
|
|
ItemList := TGtkListStoreStringList.Create(PGtkListStore(PGtkComboBox(Result)^.get_model), 0, LCLObject);
|
|
g_object_set_data(PGObject(Result), GtkListItemLCLListTag, ItemList);
|
|
|
|
PGtkComboBox(Result)^.set_entry_text_column(0);
|
|
// do not allow combo button to get focus, entry should take focus
|
|
if PGtkComboBox(Result)^.priv3^.button <> nil then
|
|
PGtkComboBox(Result)^.priv3^.button^.set_can_focus(False);
|
|
|
|
bs := Self.LCLObject.Caption;
|
|
pos := 0;
|
|
{%H-}PGtkEditable(PGtkComboBox(Result)^.get_child)^.insert_text(pgChar(PChar(bs)),length(bs),@pos);
|
|
|
|
// set lclwidget data to entry
|
|
g_object_set_data(PGtkComboBox(Result)^.get_child, 'lclwidget', Self);
|
|
// when we scroll with mouse wheel over entry our scrollevent doesn't catch entry
|
|
// but parent control with window (eg. form), so we are settint all events mask to
|
|
// catch all mouse events on gtkentry.
|
|
if IsDesigning then
|
|
begin
|
|
// maybe set disabled
|
|
{$note this does not work, must make search via children list}
|
|
(*
|
|
g_signal_connect_data(PGtkComboBox(Result)^.priv3^.button, 'button-press-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(PGtkComboBox(Result)^.priv3^.button, 'button-release-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
|
|
g_signal_connect_data(PGtkComboBox(Result)^.priv3^.arrow, 'button-press-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(PGtkComboBox(Result)^.priv3^.arrow, 'button-release-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
*)
|
|
PGtkComboBox(Result)^.priv3^.button^.set_sensitive(gtk_false);
|
|
PGtkComboBox(Result)^.priv3^.arrow^.set_sensitive(gtk_false);
|
|
|
|
g_signal_connect_data(PGtkEntry(PGtkComboBox(Result)^.get_child), 'button-press-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(PGtkEntry(PGtkComboBox(Result)^.get_child), 'button-release-event', TGCallback(@disableMouseButtonEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
|
|
// g_signal_connect_data(PGtkEntry(PGtkComboBox(Result)^.get_child), 'motion-notify-event', TGCallback(@motionNotifyEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
PGtkEntry(PGtkComboBox(Result)^.get_child)^.set_can_focus(False);
|
|
end else
|
|
PGtkEntry(PGtkComboBox(Result)^.get_child)^.set_events(GDK_DEFAULT_EVENTS_MASK);
|
|
end else
|
|
begin
|
|
// FCentralWidget := PGtkWidget(TGtkComboBox.new_with_model(PGtkTreeModel(ListStore)));
|
|
FCentralWidget := Result;
|
|
|
|
ItemList := TGtkListStoreStringList.Create(PGtkListStore(PGtkComboBox(FCentralWidget)^.get_model), 0, LCLObject);
|
|
g_object_set_data(PGObject(FCentralWidget), GtkListItemLCLListTag, ItemList);
|
|
|
|
renderer := LCLIntfCellRenderer_New();
|
|
g_object_set_data(PGObject(renderer), 'lclwidget', Self);
|
|
|
|
gtk_cell_layout_clear(PGtkCellLayout(FCentralWidget));
|
|
gtk_cell_layout_pack_start(PGtkCellLayout(FCentralWidget), renderer, True);
|
|
if not ACombo.Style.IsOwnerDrawn then
|
|
gtk_cell_layout_set_attributes(PGtkCellLayout(FCentralWidget), renderer, ['text', 0, nil]);
|
|
gtk_cell_layout_set_cell_data_func(PGtkCellLayout(FCentralWidget), renderer,
|
|
@LCLIntfCellRenderer_CellDataFunc, Self, nil);
|
|
|
|
if Assigned(PGtkComboBox(Result)^.priv3^.cell_view) then
|
|
g_object_set_data(PGObject(PGtkComboBox(Result)^.priv3^.cell_view), 'lclwidget', Self);
|
|
if Assigned(PGtkComboBox(Result)^.priv3^.button) then
|
|
g_object_set_data(PGObject(PGtkComboBox(Result)^.priv3^.button), 'lclwidget', Self);
|
|
if Assigned(PGtkComboBox(Result)^.priv3^.arrow) then
|
|
g_object_set_data(PGObject(PGtkComboBox(Result)^.priv3^.arrow), 'lclwidget', Self);
|
|
|
|
FCentralWidget := nil; //FWidget will be returned from getContainerWidget
|
|
// we need cell renderer, but we need f***g GtkEventBox too
|
|
// maybe an workaround is possible for csDropDownList (use entry with readonly param).
|
|
// if we have GtkEventBox, then ComboBox becomes FCentralWidget.
|
|
// Maybe the best thing would be to organize complete combo around GtkEntry
|
|
// Anyway , I dont see any mouse button event in this case, only when entry_set_above_child is used.
|
|
// FCentralWidget := PGtkComboBox(TGtkComboBox.new_with_model(PGtkTreeModel(ListStore)));
|
|
// PGtkEventBox(Result)^.add(FCentralWidget);
|
|
// ItemList := TGtkListStoreStringList.Create(PGtkListStore(PGtkComboBox(FCentralWidget)^.get_model), 0, LCLObject);
|
|
// g_object_set_data(PGObject(FCentralWidget), GtkListItemLCLListTag, ItemList);
|
|
// PGtkEventBox(Result)^.set_visible_window(True);
|
|
end;
|
|
g_object_unref(ListStore);
|
|
PGtkComboBox(Result)^.set_id_column(0);
|
|
Result^.show;
|
|
end;
|
|
|
|
function TGtk3ComboBox.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := AKey in [VK_UP, VK_DOWN];
|
|
end;
|
|
|
|
function TGtk3ComboBox.getText: String;
|
|
begin
|
|
Result := '';
|
|
if Gtk3IsComboBox(Widget) then
|
|
begin
|
|
with PGtkComboBox(Widget)^ do
|
|
begin
|
|
if has_entry then
|
|
begin
|
|
Result := StrPas(PGtkEntry(get_child)^.Text);
|
|
end else begin
|
|
Result := active_id;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.setText(const AValue: String);
|
|
begin
|
|
if Gtk3IsComboBox(Widget) then
|
|
begin
|
|
with PGtkComboBox(Widget)^ do
|
|
begin
|
|
if has_entry then begin
|
|
{%H-}PGtkEntry(get_child)^.Text := Pgchar(AValue);
|
|
end else begin
|
|
//active_id := Pgchar(AValue); TODO: Wait until property becomes writeble
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.DumpPrivateStructValues(const ADbgEvent: String);
|
|
var
|
|
AComboWidget: PGtkComboBox;
|
|
APrivate: PGtkComboBoxPrivate;
|
|
begin
|
|
exit;
|
|
AComboWidget := PGtkComboBox(Widget);
|
|
APrivate := PGtkComboBoxPrivate(AComboWidget^.priv3);
|
|
DebugLn('** COMBO DUMP OF PGtkComboBoxPrivate struct EVENT=',ADbgEvent);
|
|
DebugLn('BUTTON=',dbgHex({%H-}PtrUInt(APrivate^.button)),' ARROW=',dbgHex({%H-}PtrUInt(APrivate^.arrow)),
|
|
' SCROLLEDWINDOW=',dbgHex({%H-}PtrUInt(APrivate^.scrolled_window)),
|
|
' CELLVIEW=',dbgHex({%H-}PtrUInt(APrivate^.cell_view)),
|
|
' CELLAREA=',dbgHex({%H-}PtrUInt(APrivate^.area)));
|
|
DebugLn(' PrivatePopupW ',dbgHex({%H-}PtrUInt(APrivate^.popup_widget)),
|
|
' PrivatePopupWin ',dbgHex({%H-}PtrUInt(APrivate^.popup_window)),' TreeView ',dbgHex({%H-}PtrUInt(APrivate^.tree_view)));
|
|
if Gtk3IsWidget(APrivate^.popup_widget) then
|
|
begin
|
|
DebugLn('POPUPWIDGET VISIBLE ',dbgs(APrivate^.popup_widget^.get_visible),
|
|
' PopupInProgress=',dbgs(APrivate^.popup_in_progress),' POPUPSHOWN=',
|
|
dbgs(APrivate^.popup_shown),' POPUPIDLE_ID=',dbgs(APrivate^.popup_idle_id));
|
|
if Gtk3IsMenu(APrivate^.popup_widget) then
|
|
DebugLn('POPUPWIDGET IS MENU ')
|
|
else
|
|
if Gtk3IsMenuItem(APrivate^.popup_widget) then
|
|
DebugLn('POPUPWIDGET IS MENUITEM ');
|
|
end;
|
|
end;
|
|
|
|
function TGtk3ComboBox.CanFocus: Boolean;
|
|
begin
|
|
Result := False;
|
|
if IsWidgetOK then
|
|
begin
|
|
if PGtkComboBox(FWidget)^.has_entry then
|
|
Result := PGtkComboBox(FWidget)^.get_child^.can_focus
|
|
else
|
|
if GetButtonWidget <> nil then
|
|
Result := GetButtonWidget^.can_focus;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.SetBounds(ALeft, ATop, AWidth, AHeight: integer);
|
|
var
|
|
ARect: TGdkRectangle;
|
|
Alloc: TGtkAllocation;
|
|
begin
|
|
if (Widget=nil) then
|
|
exit;
|
|
|
|
LCLWidth := AWidth;
|
|
LCLHeight := AHeight;
|
|
ARect.x := ALeft;
|
|
ARect.y := ATop;
|
|
ARect.width := AWidth;
|
|
ARect.Height := AHeight;
|
|
with Alloc do
|
|
begin
|
|
x := ALeft;
|
|
y := ATop;
|
|
width := AWidth;
|
|
height := AHeight;
|
|
end;
|
|
|
|
BeginUpdate;
|
|
try
|
|
{fixes gtk3 assertion}
|
|
if not Widget^.get_realized then
|
|
Widget^.realize;
|
|
|
|
|
|
Widget^.size_allocate(@ARect);
|
|
|
|
if Widget^.get_visible then
|
|
Widget^.set_allocation(@Alloc);
|
|
|
|
if LCLObject.Parent <> nil then
|
|
Move(ALeft, ATop);
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.SetFocus;
|
|
begin
|
|
{$IFDEF GTK3DEBUGFOCUS}
|
|
DebugLn('TGtk3ComboBox.SetFocus LCLObject ',dbgsName(LCLObject),' WidgetOK ',dbgs(IsWidgetOK),
|
|
' FWidget <> GetContainerWidget ',dbgs(FWidget <> GetContainerWidget));
|
|
{$ENDIF}
|
|
if Assigned(LCLObject) then
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
if PGtkComboBox(FWidget)^.has_entry then
|
|
FWidget^.grab_focus
|
|
else
|
|
if GetButtonWidget <> nil then
|
|
GetButtonWidget^.grab_focus;
|
|
end else
|
|
inherited SetFocus;
|
|
end else
|
|
inherited SetFocus;
|
|
end;
|
|
|
|
class procedure TGtk3ComboBox.ComboBoxChanged({%H-}ACombo: PGtkComboBox; AData: gpointer); cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
if AData <> nil then
|
|
begin
|
|
if TGtk3Widget(AData).InUpdate then
|
|
Exit;
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
Msg.Msg := LM_CHANGED;
|
|
TGtk3Widget(AData).DeliverMessage(Msg);
|
|
end;
|
|
end;
|
|
|
|
function GtkPopupCloseUp(AData: Pointer): gboolean; cdecl;
|
|
begin
|
|
LCLSendCloseUpMsg(TGtk3Widget(AData).LCLObject);
|
|
Result := False;// stop the timer
|
|
end;
|
|
|
|
class procedure TGtk3ComboBox.NotifySignal(AObject: PGObject; pspec: PGParamSpec; AData: GPointer); cdecl;
|
|
var
|
|
AValue: TGValue;
|
|
ComboBox: TCustomComboBox;
|
|
begin
|
|
if pspec^.name = 'popup-shown' then
|
|
begin
|
|
ComboBox := TCustomComboBox(TGtk3Widget(AData).LCLObject);
|
|
AValue.g_type := G_TYPE_BOOLEAN;
|
|
g_object_get_property(AObject, pspec^.name, @AValue); // get property value
|
|
if AValue.data[0].v_int = 0 then // if 0 = False then it is close up
|
|
g_timeout_add(0,@GtkPopupCloseUp, AData)
|
|
else // in other case it is drop down
|
|
begin
|
|
ComboBox.IntfGetItems;
|
|
LCLSendDropDownMsg(ComboBox);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure Gtk3ComboMenuRealized({%H-}AWidget: PGtkWidget; AData: gPointer); cdecl;
|
|
begin
|
|
DebugLn('Gtk3ComboMenuRealized *****',dbgsName(TGtk3ComboBox(AData).LCLObject));
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
|
|
if IsDesigning then
|
|
exit;
|
|
// appears-as-list make it appear as list ... no way, its read only property.
|
|
//OnChange
|
|
g_signal_connect_data(GetContainerWidget, 'changed', TGCallback(@ComboBoxChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
//OnCloseUp
|
|
g_signal_connect_data(GetContainerWidget, 'notify', TGCallback(@NotifySignal), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
//TODO: if we have an entry then use CreateFrom() to create TGtk3Entry
|
|
if Gtk3IsEntry(PGtkComboBox(FWidget)^.get_child) then
|
|
begin
|
|
g_object_set_data(PGtkComboBox(FWidget)^.get_child, 'lclwidget', Self);
|
|
g_signal_connect_data(PGtkComboBox(FWidget)^.get_child, 'event', TGCallback(@WidgetEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
if GetCellView <> nil then
|
|
begin
|
|
gtk_widget_set_events(FCellView, GDK_DEFAULT_EVENTS_MASK);
|
|
g_object_set_data(FCellView, 'lclwidget', Self);
|
|
g_signal_connect_data(FCellView, 'event', TGCallback(@WidgetEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
// set to all combo widgets lclwidget data, so we will easy find TGtk3ComboBox in events.
|
|
if PGtkComboBox(GetContainerWidget)^.priv3^.button <> nil then
|
|
begin
|
|
g_object_set_data(PGObject(PGtkComboBox(GetContainerWidget)^.priv3^.button), 'lclwidget', Self);
|
|
// invalid signal for type GtkCssCustomGadget
|
|
// g_signal_connect_data(PGObject(PGtkComboBox(GetContainerWidget)^.priv3^.button), 'event', TGCallback(@WidgetEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
if PGtkComboBox(GetContainerWidget)^.priv3^.popup_widget <> nil then
|
|
begin
|
|
g_object_set_data(PGObject(PGtkComboBox(GetContainerWidget)^.priv3^.popup_widget), 'lclwidget', Self);
|
|
// invalid signal for type GtkCssCustomGadget
|
|
// g_signal_connect_data(PGObject(PGtkComboBox(GetContainerWidget)^.priv3^.popup_widget), 'event', TGCallback(@WidgetEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
//Stop gtk asserts. We must use signals on popup widget or event.
|
|
//PGtkComboBox(GetContainerWidget)^.priv3^.popup_widget^.set_has_window(True);
|
|
//PGtkComboBox(GetContainerWidget)^.priv3^.popup_widget^.set_can_focus(True);
|
|
// g_signal_connect_data(PGObject(PGtkComboBox(GetContainerWidget)^.priv3^.popup_widget), 'map', TGCallback(@Gtk3ComboMenuRealized), Self, nil, 0);
|
|
end;
|
|
if PGtkComboBox(GetContainerWidget)^.priv3^.area <> nil then
|
|
g_object_set_data(PGObject(PGtkComboBox(GetContainerWidget)^.priv3^.area), 'lclwidget', Self);
|
|
// if combo doesnt use menu
|
|
if PGtkComboBox(GetContainerWidget)^.priv3^.tree_view <> nil then
|
|
g_object_set_data(PGObject(PGtkComboBox(GetContainerWidget)^.priv3^.tree_view), 'lclwidget', Self);
|
|
// real popup menu
|
|
if PGtkComboBox(GetContainerWidget)^.priv3^.box <> nil then
|
|
g_object_set_data(PGObject(PGtkComboBox(GetContainerWidget)^.priv3^.box), 'lclwidget', Self);
|
|
|
|
end;
|
|
|
|
function TGtk3ComboBox.GetDroppedDown: boolean;
|
|
var
|
|
AValue: TGValue;
|
|
begin
|
|
Result := False;
|
|
if Assigned(FWidget) and Gtk3IsComboBox(Widget) then
|
|
begin
|
|
AValue.g_type := G_TYPE_BOOLEAN;
|
|
g_object_get_property(PGObject(Widget), 'popup-shown', @AValue);
|
|
Result := AValue.data[0].v_int <> 0;
|
|
end;
|
|
end;
|
|
|
|
class procedure TGtk3ComboBox.ComboSizeAllocate(AWidget:PGtkWidget; AGdkRect: PGdkRectangle;
|
|
Data:gpointer); cdecl;
|
|
var
|
|
Msg: TLMSize;
|
|
NewSize: TSize;
|
|
ACtl: TGtk3ComboBox;
|
|
AState: TGdkWindowState;
|
|
Alloc: TGtkAllocation;
|
|
begin
|
|
if AWidget=nil then ;
|
|
|
|
ACtl := TGtk3ComboBox(Data);
|
|
|
|
{$IF DEFINED(GTK3DEBUGCOMBOBOX) OR DEFINED(GTK3DEBUGSIZE)}
|
|
with AGdkRect^ do
|
|
DebugLn('**** ComboSizeAllocate **** ....',dbgsName(ACtl.LCLObject),
|
|
' ',Format('GTK x %d y %d w %d h %d',[x, y, width, height]),
|
|
Format(' LCL W=%d H=%d LLW %d LLH %d',[ACtl.LCLObject.Width, ACtl.LCLObject.Height, ACtl.LCLWidth, ACtl.LCLHeight]));
|
|
{$ENDIF}
|
|
|
|
with Alloc do
|
|
begin
|
|
x := AGdkRect^.x;
|
|
y := AGdkRect^.y;
|
|
Width := AGdkRect^.width;
|
|
Height := AGdkRect^.height;
|
|
end;
|
|
|
|
//gtk3 combobox is pretty ugly with it's layout
|
|
gtk_widget_set_clip(AWidget, @Alloc);
|
|
|
|
if not Assigned(ACtl.LCLObject) then exit;
|
|
|
|
// return size w/o frame
|
|
NewSize.cx := AGdkRect^.width;
|
|
NewSize.cy := AGdkRect^.height;
|
|
|
|
|
|
if not (csDesigning in ACtl.LCLObject.ComponentState) then
|
|
begin
|
|
if ACtl.InUpdate then
|
|
exit;
|
|
end;
|
|
|
|
if ((NewSize.cx <> ACtl.LCLObject.Width) or (NewSize.cy <> ACtl.LCLObject.Height) or
|
|
ACtl.LCLObject.ClientRectNeedsInterfaceUpdate) then
|
|
begin
|
|
{TODO: check if this is needed}
|
|
ACtl.LCLObject.DoAdjustClientRectChange;
|
|
end;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_SIZE;
|
|
Msg.SizeType := SIZE_RESTORED;
|
|
|
|
Msg.SizeType := Msg.SizeType or Size_SourceIsInterface;
|
|
|
|
Msg.Width := Word(NewSize.cx);
|
|
Msg.Height := Word(NewSize.cy);
|
|
ACtl.DeliverMessage(Msg);
|
|
end;
|
|
|
|
procedure TGtk3ComboBox.ConnectSizeAllocateSignal(ToWidget:PGtkWidget);
|
|
begin
|
|
g_signal_connect_data(ToWidget,'size-allocate',TGCallback(@ComboSizeAllocate), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
{ TGtk3Button }
|
|
|
|
function TGtk3Button.getLayout: Integer;
|
|
begin
|
|
Result := FLayout;
|
|
// PGtkButton(FWidget)^.get_image_position;
|
|
end;
|
|
|
|
function TGtk3Button.getMargin: Integer;
|
|
begin
|
|
Result := FMargin;
|
|
end;
|
|
|
|
procedure TGtk3Button.SetLayout(AValue: Integer);
|
|
begin
|
|
FLayout := AValue;
|
|
if IsWidgetOk then
|
|
begin
|
|
PGtkButton(FWidget)^.set_image_position(TGtkPositionType(AValue));
|
|
// set margin and spacing when layout is changed
|
|
SetMargin(FMargin);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Button.SetMargin(AValue: Integer);
|
|
begin
|
|
FMargin := AValue;
|
|
if not IsWidgetOK then
|
|
exit;
|
|
if FMargin = -1 then
|
|
PGtkButton(FWidget)^.set_alignment(0.5, 0.5)
|
|
else
|
|
begin
|
|
case FLayout of
|
|
0 {GTK_POS_LEFT}: PGtkButton(FWidget)^.set_alignment(0, 0.5);
|
|
1 {GTK_POS_RIGHT}: PGtkButton(FWidget)^.set_alignment(1.0, 0.5);
|
|
2 {GTK_POS_TOP}: PGtkButton(FWidget)^.set_alignment(0.5, 0);
|
|
3 {GTK_POS_BOTTOM}: PGtkButton(FWidget)^.set_alignment(0.5, 1);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Button.SetSpacing(AValue: Integer);
|
|
var
|
|
ATGValue: TGValue;
|
|
AImage: PGtkWidget;
|
|
begin
|
|
// if FSpacing=AValue then Exit;
|
|
FSpacing:=AValue;
|
|
if AValue < 0 then
|
|
FSpacing := 2;
|
|
ATGValue.g_type := G_TYPE_INT;
|
|
ATGValue.set_int(AValue);
|
|
|
|
// no way under gtk3 ... we cannot set style property image-spacing
|
|
// so we are using cheat
|
|
AImage := PGtkButton(FWidget)^.get_image;
|
|
if AImage <> nil then
|
|
begin
|
|
if AValue < 0 then
|
|
AVAlue := 0;
|
|
//TODO: margin depends on layout ! This is ok for left (default) layout
|
|
PGtkImage(AImage)^.set_margin_right(AValue);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Button.SetImage(AImage: TBitmap);
|
|
begin
|
|
if Assigned(fImage) then
|
|
fImage.free;
|
|
fImage:=AImage;
|
|
end;
|
|
|
|
function TGtk3Button.getText: String;
|
|
begin
|
|
if IsWidgetOK then
|
|
Result := {%H-}ReplaceUnderscoresWithAmpersands(PGtkButton(FWidget)^.get_label())
|
|
else
|
|
Result := '';
|
|
end;
|
|
|
|
procedure TGtk3Button.setText(const AValue: String);
|
|
begin
|
|
if IsWidgetOk then
|
|
begin
|
|
{%H-}PGtkButton(FWidget)^.set_label(PgChar({%H-}ReplaceAmpersandsWithUnderscores(AValue)));
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Button.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
btn:PGtkButton absolute Result;
|
|
begin
|
|
Result := LCLGtkButtonNew;
|
|
|
|
btn^.set_use_underline(true);
|
|
|
|
if not IsDesigning then
|
|
LCLObject.ControlStyle:=LCLObject.ControlStyle+[csClickEvents];
|
|
|
|
FMargin := -1;
|
|
FLayout := ord(GTK_POS_LEFT);
|
|
FSpacing := 2; // default gtk3 spacing is 2
|
|
end;
|
|
|
|
destructor TGtk3Button.Destroy;
|
|
begin
|
|
SetImage(nil);
|
|
inherited Destroy;
|
|
end;
|
|
|
|
class function TGtk3Button.ButtonMouseEvent(aWidget: PGtkWidget; aEvent: PGdkEvent; aData: gpointer): gboolean; cdecl;
|
|
begin
|
|
Result := TGtk3Widget(aData).GtkEventMouse(aWidget, aEvent);
|
|
end;
|
|
|
|
function ButtonMotionNotifyEvent(widget: PGtkWidget; event: PGdkEvent; user_data: gpointer): gboolean; cdecl;
|
|
begin
|
|
TGtk3Widget(user_data).GtkEventMouseMove(widget, event);
|
|
Result := True;
|
|
end;
|
|
|
|
procedure TGtk3Button.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
if not IsDesigning then
|
|
begin
|
|
g_signal_connect_data(GetContainerWidget, 'button-press-event', TGCallback(@ButtonMouseEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(GetContainerWidget, 'button-release-event', TGCallback(@ButtonMouseEvent), Self, Nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Button.IsWidgetOk: Boolean;
|
|
begin
|
|
Result := (FWidget <> nil) and Gtk3IsButton(FWidget);
|
|
end;
|
|
|
|
procedure TGtk3Button.SetDefault(const ADefault: Boolean);
|
|
begin
|
|
if IsWidgetOk then
|
|
GetContainerWidget^.set_can_default(ADefault);
|
|
end;
|
|
|
|
{ TGtk3ToggleButton }
|
|
procedure Gtk3Toggled({%H-}AWidget: PGtkToggleButton; AData: gPointer); cdecl;
|
|
var
|
|
Msg: TLMessage;
|
|
begin
|
|
FillChar(Msg{%H-}, SizeOf(Msg), 0);
|
|
Msg.Msg := LM_CHANGED;
|
|
if (TGtk3Widget(AData).LCLObject <> nil) and not TGtk3Widget(AData).InUpdate then
|
|
TGtk3Widget(AData).DeliverMessage(Msg, False);
|
|
end;
|
|
|
|
procedure TGtk3ToggleButton.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
if not IsDesigning then
|
|
g_signal_connect_data(FWidget, 'toggled', TGCallback(@Gtk3Toggled), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
function TGtk3ToggleButton.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
btn: PGtkToggleButton;
|
|
begin
|
|
btn := TGtkToggleButton.new;
|
|
btn^.use_underline := True;
|
|
Result := PGtkWidget(btn);
|
|
end;
|
|
|
|
{ TGtk3CheckBox }
|
|
|
|
function TGtk3CheckBox.GetState: TCheckBoxState;
|
|
begin
|
|
Result := cbUnchecked;
|
|
if IsWidgetOk then
|
|
begin
|
|
if PGtkCheckButton(FWidget)^.get_inconsistent then
|
|
Result := cbGrayed
|
|
else
|
|
if PGtkCheckButton(FWidget)^.get_active then
|
|
Result := cbChecked;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3CheckBox.SetState(AValue: TCheckBoxState);
|
|
begin
|
|
if IsWidgetOK then
|
|
begin
|
|
if AValue = cbGrayed then
|
|
PGtkCheckButton(FWidget)^.set_inconsistent(True)
|
|
else
|
|
PGtkCheckButton(FWidget)^.set_active(AValue = cbChecked);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3CheckBox.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
check: PGtkCheckButton;
|
|
begin
|
|
check := TGtkCheckButton.new;
|
|
Result := PGtkWidget(check);
|
|
check^.set_use_underline(True);
|
|
end;
|
|
|
|
procedure TGtk3CheckBox.SetBounds(ALeft,ATop,AWidth,AHeight:integer);
|
|
var
|
|
Alloc:TGtkAllocation;
|
|
begin
|
|
if LCLObject.Name = 'HiddenRadioButton' then
|
|
exit;
|
|
LCLWidth := AWidth;
|
|
LCLHeight := AHeight;
|
|
// not needed
|
|
// Widget^.set_size_request(AWidth, AHeight);
|
|
Alloc.x := ALeft;
|
|
Alloc.y := ATop;
|
|
Alloc.width := AWidth;
|
|
Alloc.height := AHeight;
|
|
Widget^.set_allocation(@Alloc);
|
|
Move(ALeft, ATop);
|
|
end;
|
|
|
|
{ TGtk3RadioButton }
|
|
|
|
function TGtk3RadioButton.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
btn: PGtkRadioButton;
|
|
w: PGtkWidget;
|
|
ctl, Parent: TWinControl;
|
|
rb: TRadioButton;
|
|
//pl: PGsList;
|
|
i: Integer;
|
|
begin
|
|
if Self.LCLObject.Name='HiddenRadioButton' then
|
|
exit;
|
|
btn := TGtkRadioButton.new(nil);
|
|
btn^.use_underline := True;
|
|
Result := PGtkWidget(btn);
|
|
ctl := Self.LCLObject;
|
|
if Assigned(ctl) then
|
|
begin
|
|
Parent := ctl.Parent;
|
|
if (Parent is TRadioGroup) then
|
|
begin
|
|
if (TRadioGroup(Parent).Items.Count>0) then
|
|
begin
|
|
rb := TRadioButton(Parent.Controls[0]);
|
|
if rb<>ctl then
|
|
begin
|
|
w := TGtk3RadioButton(rb.Handle).Widget;
|
|
//pl := PGtkRadioButton(w)^.get_group;
|
|
//PGtkRadioButton(Result)^.set_group(pl);
|
|
PGtkRadioButton(Result)^.join_group(PGtkRadioButton(w));
|
|
end;
|
|
end
|
|
end
|
|
else
|
|
begin
|
|
for i := 0 to Parent.ControlCount - 1 do
|
|
if (Parent.Controls[i] is TRadioButton) and
|
|
TWinControl(Parent.Controls[i]).HandleAllocated then
|
|
begin
|
|
rb := TRadioButton(Parent.Controls[i]);
|
|
w := TGtk3RadioButton(rb.Handle).Widget;
|
|
//pl := PGtkRadioButton(w)^.get_group;
|
|
//PGtkRadioButton(Result)^.set_group(pl);
|
|
PGtkRadioButton(Result)^.join_group(PGtkRadioButton(w));
|
|
Break;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3RadioButton.InitializeWidget;
|
|
begin
|
|
if Self.LCLObject.Name='HiddenRadioButton' then
|
|
begin
|
|
exit;
|
|
{ PGtkRadioButton(Self.Widget)^.set_group(nil);
|
|
// PGtkRadioButton(Self.Widget)^.set_inconsistent(true);
|
|
PGtkRadioButton(Self.Widget)^.set_visible(false);}
|
|
end;
|
|
inherited InitializeWidget;
|
|
end;
|
|
|
|
function TGtk3RadioButton.getClientRect:TRect;
|
|
var
|
|
Alloc:TGtkAllocation;
|
|
R: TRect;
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
//Famous "HiddenRadioButton"
|
|
if (Widget = nil) then
|
|
exit;
|
|
Widget^.get_allocation(@Alloc);
|
|
Result := Bounds(Alloc.x, Alloc.y, Alloc.Width, Alloc.Height);
|
|
Types.OffsetRect(Result, -Result.Left, -Result.Top);
|
|
end;
|
|
|
|
|
|
{ TGtk3CustomControl }
|
|
|
|
function TGtk3CustomControl.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
FHasPaint := True;
|
|
FKeysToEat := [];
|
|
|
|
FWidgetType := [wtWidget, wtLayout, wtTabControl, wtScrollingWin, wtCustomControl];
|
|
|
|
// this hack is requred for controls without custom WS classes
|
|
if LCLObject is TUpDown then
|
|
include(FWidgetType,wtSpinEdit);
|
|
|
|
Result := PGtkScrolledWindow(TGtkScrolledWindow.new(nil, nil));
|
|
|
|
FCentralWidget := TGtkLayout.new(nil, nil);
|
|
|
|
PGtkScrolledWindow(Result)^.add(FCentralWidget);
|
|
|
|
PGtkScrolledWindow(Result)^.set_policy(GTK_POLICY_EXTERNAL, GTK_POLICY_EXTERNAL);
|
|
|
|
Result^.set_can_focus(False);
|
|
FCentralWidget^.set_can_focus(True);
|
|
FCentralWidget^.set_app_paintable(True);
|
|
PGtkScrolledWindow(Result)^.set_shadow_type(BorderStyleShadowMap[TCustomControl(LCLObject).BorderStyle]);
|
|
if not (csDesigning in LCLObject.ComponentState) then
|
|
g_object_set(PGObject(FCentralWidget), 'resize-mode', [GTK_RESIZE_QUEUE, nil]);
|
|
gtk_layout_set_size(PGtkLayout(FCentralWidget), 1, 1);
|
|
|
|
g_signal_connect_data(FCentralWidget,'size-allocate',TGCallback(@ScrolledLayoutSizeAllocate), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
with PGtkScrolledWindow(Result)^.get_vadjustment^ do
|
|
LCLVAdj := gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
|
|
with PGtkScrolledWindow(Result)^.get_hadjustment^ do
|
|
LCLHAdj := gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
|
|
end;
|
|
|
|
function TGtk3CustomControl.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
procedure TGtk3CustomControl.DoBeforeLCLPaint;
|
|
var
|
|
DC: TGtk3DeviceContext;
|
|
NColor: TColor;
|
|
begin
|
|
inherited DoBeforeLCLPaint;
|
|
if not Visible then
|
|
exit;
|
|
|
|
DC := TGtk3DeviceContext(Context);
|
|
|
|
NColor := LCLObject.Color;
|
|
if (NColor <> clNone) and (NColor <> clDefault) then
|
|
begin
|
|
DC.CurrentBrush.Color := ColorToRGB(NColor);
|
|
DC.fillRect(0, 0, LCLObject.Width, LCLObject.Height);
|
|
end;
|
|
|
|
if BorderStyle <> bsNone then
|
|
begin
|
|
DC.CurrentPen.Color := ColorToRGB(clBtnShadow); // not sure what color to use here?
|
|
DC.drawRect(0, 0, LCLObject.Width, LCLObject.Height, False, True);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3CustomControl.OffsetMousePos(APoint: PPoint);
|
|
var
|
|
Hadjustment, Vadjustment: PGtkAdjustment;
|
|
HValue, VValue: longint;
|
|
begin
|
|
inherited OffsetMousePos(APoint);
|
|
// Retrieve adjustments
|
|
Hadjustment := GetScrolledWindow^.get_hadjustment;
|
|
Vadjustment := GetScrolledWindow^.get_vadjustment;
|
|
|
|
// Get the adjustment values
|
|
HValue := Round(gtk_adjustment_get_value(Hadjustment));
|
|
VValue := Round(gtk_adjustment_get_value(Vadjustment));
|
|
|
|
// Apply adjustment values to the mouse position
|
|
Dec(APoint^.x, HValue);
|
|
Dec(APoint^.y, VValue);
|
|
end;
|
|
|
|
procedure TGtk3CustomControl.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
if not IsDesigning then
|
|
begin
|
|
g_signal_connect_data(gtk_scrolled_window_get_hscrollbar(GetScrolledWindow), 'change-value',
|
|
TGCallback(@RangeChangeValue), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(gtk_scrolled_window_get_vscrollbar(GetScrolledWindow), 'change-value',
|
|
TGCallback(@RangeChangeValue), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
g_signal_connect_data(PGtkRange(gtk_scrolled_window_get_hscrollbar(GetScrolledWindow)),'value-changed',
|
|
TGCallback(@RangeValueChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(PGtkRange(gtk_scrolled_window_get_vscrollbar(GetScrolledWindow)),'value-changed',
|
|
TGCallback(@RangeValueChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3CustomControl.getViewport:PGtkViewport;
|
|
begin
|
|
Result := PGtkViewport(PGtkScrolledWindow(Widget)^.get_child);
|
|
end;
|
|
|
|
procedure TGtk3CustomControl.preferredSize(var PreferredWidth,PreferredHeight:
|
|
integer;WithThemeSpace:Boolean);
|
|
begin
|
|
inherited preferredSize(PreferredWidth, PreferredHeight, WithThemeSpace);
|
|
if [wtCustomControl] * WidgetType <> [] then
|
|
begin
|
|
PreferredWidth := 0;
|
|
PreferredHeight := 0;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3CustomControl.getClientRect: TRect;
|
|
var
|
|
Allocation: TGtkAllocation;
|
|
R: TRect;
|
|
w, h, x, y, VOffset, HOffset: gint;
|
|
AViewPort: PGtkViewport;
|
|
Bar:PGtkScrollbar;
|
|
AWindow: PGdkWindow;
|
|
AHorzPolicy, AVertPolicy: TGtkPolicyType;
|
|
begin
|
|
if [wtLayout] * WidgetType <> [] then
|
|
begin
|
|
Result := Rect(0, 0, 0, 0);
|
|
AWindow := PGtkLayout(getContainerWidget)^.get_window;
|
|
if (AWindow <> nil) and Gtk3IsGdkWindow(AWindow) then
|
|
begin
|
|
HOffset := 0;
|
|
VOffset := 0;
|
|
gtk_scrolled_window_get_policy(PGtkScrolledWindow(Widget), @AHorzPolicy, @AVertPolicy);
|
|
if AHorzPolicy < GTK_POLICY_NEVER then
|
|
begin
|
|
Bar := getHorizontalScrollbar;
|
|
if (Bar <> nil) and Gtk3IsWidget(Bar) and Bar^.get_visible and GTK3WidgetSet.OverlayScrolling then
|
|
HOffset := Bar^.get_allocated_height;
|
|
end;
|
|
if AVertPolicy < GTK_POLICY_NEVER then
|
|
begin
|
|
Bar := getVerticalScrollbar;
|
|
if (Bar <> nil) and Gtk3IsWidget(Bar) and Bar^.get_visible and GTK3WidgetSet.OverlayScrolling then
|
|
VOffset := Bar^.get_allocated_width
|
|
end;
|
|
|
|
Result := Rect(0, 0, AWindow^.get_width - VOffset, AWindow^.get_height - HOffset);
|
|
end else
|
|
begin
|
|
//we are not ready, provide at least scrolledwindow size as clientrect for now.
|
|
Result := Rect(0, 0, PGtkLayout(GetContainerWidget)^.get_allocated_width, PGtkLayout(GetContainerWidget)^.get_allocated_height);
|
|
if (Result.Width <= 1) and (Result.Height <= 1) then
|
|
Result := Rect(0, 0, Widget^.get_allocated_width, Widget^.get_allocated_height);
|
|
end;
|
|
end else //we are wtContext - GtkFixed based.
|
|
begin
|
|
AViewport := getViewport;
|
|
if Gtk3IsViewPort(AViewPort) and Gtk3IsGdkWindow(AViewPort^.get_view_window) then
|
|
begin
|
|
AViewPort^.get_view_window^.get_geometry(@x, @y, @w, @h);
|
|
|
|
Bar := getHorizontalScrollbar;
|
|
if (Bar <> nil) and Gtk3IsWidget(Bar) and Bar^.get_visible and GTK3WidgetSet.OverlayScrolling then
|
|
HOffset := Bar^.get_allocated_height
|
|
else
|
|
HOffset := 0;
|
|
|
|
Bar := getVerticalScrollbar;
|
|
if (Bar <> nil) and Gtk3IsWidget(Bar) and Bar^.get_visible and GTK3WidgetSet.OverlayScrolling then
|
|
VOffset := Bar^.get_allocated_width
|
|
else
|
|
VOffset := 0;
|
|
|
|
Result := Rect(0, 0, AViewPort^.get_view_window^.get_width - VOffset, AViewPort^.get_view_window^.get_height - HOffset);
|
|
|
|
{$IFDEF GTK3DEBUGSIZE}
|
|
DebugLn('TGtk3CustomControl.GetClientRect via Viewport ',dbgsName(LCLObject),' Result ',dbgs(Result),' X=',dbgs(X),' Y=',dbgs(Y),' AllocH=',dbgs(AViewPort^.get_allocated_height),' OffsetH=',HOffset.ToString,' VOffset=',VOffset.ToString);
|
|
getContainerWidget^.get_allocation(@Allocation);
|
|
with ALlocation do
|
|
begin
|
|
DebugLn(Format(' GtkFixed alloc x %d y %d width %d height %d',[x, y, width, height]));
|
|
end;
|
|
{$ENDIF}
|
|
|
|
exit; // we are done here
|
|
end else
|
|
begin
|
|
FCentralWidget^.get_allocation(@Allocation);
|
|
if (Allocation.x = -1) and (Allocation.y = -1) and (Allocation.width <= 1) and (Allocation.Height <= 1) then
|
|
FWidget^.get_allocation(@Allocation);
|
|
end;
|
|
|
|
with Allocation do
|
|
R := Rect(x, y, width + x, height + y);
|
|
|
|
if IsRectEmpty(R) then
|
|
R := Rect(0, 0, 0, 0);
|
|
|
|
Result := R;
|
|
{$IFDEF GTK3DEBUGSIZE}
|
|
DebugLn('TGtk3CustomControl.GetClientRect via GtkFixed ',dbgsName(LCLObject),' Result=',dbgs(Result));
|
|
{$ENDIF}
|
|
|
|
// DebugLn('TGtk3CustomControl.GetClientRect normal ',dbgsName(LCLObject),' Result ',dbgs(Result));
|
|
Types.OffsetRect(Result, -Result.Left, -Result.Top);
|
|
|
|
end;
|
|
end;
|
|
|
|
function TGtk3CustomControl.getHorizontalScrollbar: PGtkScrollbar;
|
|
var
|
|
HPolicy:TGtkPolicyType;
|
|
VPolicy:TGtkPolicyType;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
PGtkScrolledWindow(Widget)^.get_policy(@HPolicy, @VPolicy);
|
|
if HPolicy >= GTK_POLICY_NEVER then
|
|
exit;
|
|
Result := PGtkScrollBar(PGtkScrolledWindow(Widget)^.get_hscrollbar);
|
|
g_object_set_data(Result,'lclwidget',Self);
|
|
end;
|
|
|
|
function TGtk3CustomControl.getVerticalScrollbar: PGtkScrollbar;
|
|
var
|
|
VPolicy:TGtkPolicyType;
|
|
HPolicy:TGtkPolicyType;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
PGtkScrolledWindow(Widget)^.get_policy(@HPolicy, @VPolicy);
|
|
if VPolicy >= GTK_POLICY_NEVER then
|
|
exit;
|
|
Result := PGtkScrollBar(PGtkScrolledWindow(Widget)^.get_vscrollbar);
|
|
g_object_set_data(Result,'lclwidget',Self);
|
|
end;
|
|
|
|
function TGtk3CustomControl.GetScrolledWindow: PGtkScrolledWindow;
|
|
begin
|
|
if IsWidgetOK then
|
|
Result := PGtkScrolledWindow(Widget)
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
{ TGtk3ScrollingWinControl }
|
|
|
|
class procedure TGtk3ScrollingWinControl.ScrollingWinControlFixedSizeAllocate(AWidget: PGtkWidget;
|
|
AGdkRect: PGdkRectangle; Data: gpointer); cdecl;
|
|
var
|
|
hadj, vadj: PGtkAdjustment;
|
|
HSize,VSize: Integer;
|
|
begin
|
|
//writeln('GtkFixed size-allocate x=',AGdkRect^.x,' Y=',AGdkRect^.y,' Width=',AGdkRect^.width,' H=',AGdkRect^.height,' VAdj ? ',Assigned(TGtk3CustomControl(Data).LCLVAdj));
|
|
VSize := 0;
|
|
HSize := 0;
|
|
hadj := TGtk3ScrollableWin(Data).GetScrolledWindow^.get_hadjustment;
|
|
vadj := TGtk3ScrollableWin(Data).GetScrolledWindow^.get_vadjustment;
|
|
|
|
if Assigned(TGtk3ScrollableWin(Data).LCLVAdj) and Gtk3IsAdjustment(vadj) then
|
|
with TGtk3ScrollableWin(Data).LCLVAdj^ do
|
|
begin
|
|
VSize := Round(upper);
|
|
if page_size > 0 then
|
|
VSize := VSize + Round(upper - page_size);
|
|
end;
|
|
|
|
if Assigned(TGtk3ScrollableWin(Data).LCLHAdj) and Gtk3IsAdjustment(hadj) then
|
|
with TGtk3ScrollableWin(Data).LCLHAdj^ do
|
|
begin
|
|
HSize := Round(upper);
|
|
if page_size > 0 then
|
|
HSize := HSize + Round(upper - page_size);
|
|
end;
|
|
|
|
HSize := Max(AGdkRect^.Width, HSize);
|
|
VSize := Max(AGdkRect^.Height, VSize);
|
|
|
|
//TODO: check if call resizing is needed when GtkFixed equals new size !
|
|
|
|
PGtkFixed(Awidget)^.set_size_request(HSize, VSize);
|
|
|
|
{TODO: eg treeview editor, if scrollbar value > 0 then editor resets position to 0,
|
|
to fix this we must position editor at y pos - adjustment.value}
|
|
if Assigned(TGtk3ScrollableWin(Data).LCLVAdj) and Gtk3IsAdjustment(vadj) then
|
|
with TGtk3ScrollableWin(Data).LCLVAdj^ do
|
|
vadj^.configure({vadj^.}value, lower, upper, step_increment, page_increment, page_size);
|
|
|
|
if Assigned(TGtk3ScrollableWin(Data).LCLHAdj) and Gtk3IsAdjustment(hadj) then
|
|
with TGtk3ScrollableWin(Data).LCLHAdj^ do
|
|
hadj^.configure({hadj^.}value, lower, upper, step_increment, page_increment, page_size);
|
|
|
|
if TGtk3ScrollableWin(Data).LCLObject.ClientRectNeedsInterfaceUpdate then
|
|
TGtk3ScrollableWin(Data).LCLObject.DoAdjustClientRectChange;
|
|
|
|
end;
|
|
|
|
function TGtk3ScrollingWinControl.CreateWidget(const Params: TCreateParams
|
|
): PGtkWidget;
|
|
begin
|
|
FHasPaint := True;
|
|
FWidgetType := [wtWidget, wtContainer, wtScrollingWin, wtScrollingWinControl];
|
|
Result := PGtkScrolledWindow(TGtkScrolledWindow.new(nil, nil));
|
|
FCentralWidget := LCLGtkFixedNew;
|
|
FCentralWidget^.set_hexpand(True);
|
|
FCentralWidget^.set_vexpand(True);
|
|
FCentralWidget^.set_has_window(True);
|
|
FCentralWidget^.show;
|
|
|
|
PGtkScrolledWindow(Result)^.add_with_viewport(FCentralWidget);
|
|
|
|
PGtkViewport(PGtkScrolledWindow(Result)^.get_child)^.set_shadow_type(BorderStyleShadowMap[bsNone]);
|
|
PGtkScrolledWindow(Result)^.set_shadow_type(BorderStyleShadowMap[TScrollingWinControl(LCLObject).BorderStyle]);
|
|
PGtkScrolledWindow(Result)^.get_vscrollbar^.set_can_focus(False);
|
|
PGtkScrolledWindow(Result)^.get_hscrollbar^.set_can_focus(False);
|
|
PGtkScrolledWindow(Result)^.set_policy(GTK_POLICY_NEVER, GTK_POLICY_NEVER);
|
|
|
|
// this is very important
|
|
PGtkScrolledWindow(Result)^.set_can_focus(False);
|
|
FCentralWidget^.set_can_focus(True);
|
|
|
|
g_signal_connect_data(FCentralWidget,'size-allocate',TGCallback(@ScrollingWinControlFixedSizeAllocate), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
with PGtkScrolledWindow(Result)^.get_vadjustment^ do
|
|
LCLVAdj := gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
|
|
with PGtkScrolledWindow(Result)^.get_hadjustment^ do
|
|
LCLHAdj := gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
|
|
|
|
end;
|
|
|
|
{ TGtk3Window }
|
|
|
|
function TGtk3Window.GetTitle: String;
|
|
begin
|
|
if Gtk3IsGtkWindow(fWidget) then
|
|
Result:=PGtkWindow(fWidget)^.get_title()
|
|
else
|
|
Result:=''
|
|
end;
|
|
|
|
procedure TGtk3Window.SetIcon(AValue: PGdkPixBuf);
|
|
begin
|
|
// if FIcon=AValue then Exit;
|
|
if Assigned(FIcon) then
|
|
begin
|
|
FIcon^.unref;
|
|
FIcon := nil;
|
|
end;
|
|
if Gtk3IsGdkPixbuf(AValue) then
|
|
FIcon := PGdkPixbuf(AValue)^.copy
|
|
else
|
|
FIcon := nil;
|
|
// DebugLn('Setting icon ',dbgHex(PtrUInt(FIcon)),' AppIcon ',dbgHex(PtrUInt(GTK3WidgetSet.AppIcon)));
|
|
if Gtk3IsGtkWindow(fWidget) then
|
|
PGtkWindow(Widget)^.set_icon(FIcon);
|
|
end;
|
|
|
|
function TGtk3Window.GetSkipTaskBarHint: Boolean;
|
|
begin
|
|
Result := False;
|
|
if Gtk3IsGtkWindow(fWidget) then
|
|
Result := PGtkWindow(Widget)^.get_skip_taskbar_hint;
|
|
end;
|
|
|
|
procedure TGtk3Window.SetSkipTaskBarHint(AValue: Boolean);
|
|
begin
|
|
if Gtk3IsGtkWindow(fWidget) then
|
|
PGtkWindow(Widget)^.set_skip_taskbar_hint(AValue);
|
|
end;
|
|
|
|
procedure TGtk3Window.SetTitle(const AValue: String);
|
|
begin
|
|
if Gtk3IsGtkWindow(fWidget) then
|
|
{%H-}PGtkWindow(FWidget)^.set_title(PGChar(AValue));
|
|
end;
|
|
|
|
class function TGtk3Window.WindowStateSignal(AWidget: PGtkWidget;
|
|
AEvent: PGdkEvent; AData: gPointer): gboolean; cdecl;
|
|
var
|
|
Msg: TLMSize;
|
|
AState: TGdkWindowState;
|
|
//AScreen: PGdkScreen;
|
|
msk: TGdkWindowState;
|
|
begin
|
|
Result := False;
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_SIZE;
|
|
Msg.SizeType := SIZE_RESTORED;
|
|
|
|
msk:=AEvent^.window_state.changed_mask;
|
|
AState:=AEvent^.window_state.new_window_state;
|
|
|
|
if GDK_WINDOW_STATE_ICONIFIED in msk then
|
|
begin
|
|
if GDK_WINDOW_STATE_ICONIFIED in AState then
|
|
Msg.SizeType := SIZE_MINIMIZED
|
|
end else
|
|
if GDK_WINDOW_STATE_MAXIMIZED in msk then
|
|
begin
|
|
if GDK_WINDOW_STATE_MAXIMIZED in AState then
|
|
Msg.SizeType := SIZE_MAXIMIZED
|
|
end else
|
|
if GDK_WINDOW_STATE_FULLSCREEN in msk then
|
|
begin
|
|
if GDK_WINDOW_STATE_FULLSCREEN in AState then
|
|
Msg.SizeType := SIZE_FULLSCREEN
|
|
end else
|
|
if GDK_WINDOW_STATE_FOCUSED in msk then
|
|
begin
|
|
{$IFDEF GTK3DEBUGWINDOWSTATE}
|
|
if GDK_WINDOW_STATE_FOCUSED in AState then
|
|
DebugLn('Gtk3WindowState: Focused')
|
|
else
|
|
DebugLn('Gtk3WindowState: Defocused');
|
|
{$ENDIF}
|
|
exit;
|
|
end else
|
|
if GDK_WINDOW_STATE_WITHDRAWN in msk then
|
|
begin
|
|
{$IFDEF GTK3DEBUGWINDOWSTATE}
|
|
if GDK_WINDOW_STATE_WITHDRAWN in AState then
|
|
DebugLn('Gtk3WindowState: Shown')
|
|
else
|
|
DebugLn('Gtk3WindowState: Hidden');
|
|
{$ENDIF}
|
|
exit;
|
|
end else
|
|
begin
|
|
//DebugLn(format('other changes state=%.08x mask=%.08x',[AState,msk]));
|
|
exit;
|
|
end;
|
|
|
|
Msg.SizeType := Msg.SizeType or Size_SourceIsInterface;
|
|
|
|
Msg.Width := Word(AWidget^.window^.get_width);
|
|
Msg.Height := Word(AWidget^.window^.get_height);
|
|
{$IFDEF GTK3DEBUGWINDOWSTATE}
|
|
DebugLn('GetWindowState SizeType=',dbgs(Msg.SizeType),' realized ',dbgs(AWidget^.get_realized));
|
|
{$ENDIF}
|
|
TGtk3Window(AData).DeliverMessage(Msg);
|
|
// DeliverMessage(Msg);
|
|
end;
|
|
|
|
class procedure TGtk3Window.WindowSizeAllocate(AWidget:PGtkWidget;AGdkRect:
|
|
PGdkRectangle;Data:gpointer);cdecl;
|
|
var
|
|
Msg: TLMSize;
|
|
NewSize: TSize;
|
|
ACtl: TGtk3Widget;
|
|
AState: TGdkWindowState;
|
|
Alloc: TGtkAllocation;
|
|
ADefW, ADefH: gint;
|
|
begin
|
|
if AWidget=nil then ;
|
|
|
|
ACtl := TGtk3Widget(Data);
|
|
|
|
//When gtk3 form is shown for the first time under some window manager there's
|
|
//geometry out of sync. We fix it via map-event and WidgetMapped property.
|
|
if g_object_get_data(aWidget,'lcl-window-first-map') <> nil then
|
|
begin
|
|
g_object_set_data(aWidget,'lcl-window-first-map', nil);
|
|
if not IsRectEmpty(TGtk3Window(ACtl).FFirstMapRect) then
|
|
begin
|
|
with TGtk3Window(ACtl) do
|
|
Types.OffsetRect(FFirstMapRect, -FFirstMapRect.Left, -FFirstMapRect.Top);
|
|
AGdkRect^ := GdkRectFromRect(TGtk3Window(ACtl).FFirstMapRect);
|
|
TGtk3Window(ACtl).FFirstMapRect := Rect(0, 0, 0, 0);
|
|
end;
|
|
end;
|
|
|
|
{$IFDEF GTK3DEBUGFORMS}
|
|
if Assigned(ACtl.LCLObject) then
|
|
begin
|
|
with ACtl.LCLObject do
|
|
begin
|
|
writeln(Format('TGtk3Window.WindowSizeAllocate %s Gdk x %d y %d w %d h %d LCL l %d t %d w %d h %d applied w %d h %d cliRect %s WMap %s',[dbgsName(ACtl.LCLObject), AGdkRect^.x, AGdkRect^.y, AGdkRect^.width, AGdkRect^.height, Left, Top, Width, Height, ACtl.LCLWidth, ACtl.LCLHeight, dbgs(ACtl.LCLObject.ClientRect), BoolToStr(ACtl.WidgetMapped, True)]));
|
|
end;
|
|
if (AGdkRect^.x = 0) and (AGdkRect^.y = 0) and (AGdkRect^.width = 200) and (AGdkRect^.height = 200) and ACtl.WidgetMapped then
|
|
begin
|
|
// this is wrong size. This one is sent by kwin.
|
|
writeln('***** Dump size values for ',G_OBJECT_TYPE_NAME(AWidget));
|
|
with PGtkWindow(AWidget)^ do
|
|
begin
|
|
get_allocation(@Alloc);
|
|
get_size(@NewSize.cx, @NewSize.cy);
|
|
get_default_size(@ADefW, @ADefH);
|
|
end;
|
|
with Alloc do
|
|
writeln(Format('WSA Alloc x %d y %d w %d h %d NS w %d h %d DEF w %d h %d', [x, y, width, height, NewSize.cx, NewSize.cy, ADefW, ADefH]));
|
|
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
if decoration_flags(TCustomForm(Actl.LCLObject))<>[] then
|
|
PGtkWIndow(Actl.widget)^.get_size(@newSize.cx, @newsize.cy)
|
|
else
|
|
begin
|
|
NewSize.cx := AGdkRect^.width;
|
|
NewSize.cy := AGdkRect^.height;
|
|
end;
|
|
|
|
//writeln(format('Gkt3SizeAllocate w=%d h=%d',[NewSize.cx,NewSize.cy]));
|
|
|
|
if not Assigned(ACtl.LCLObject) then exit;
|
|
|
|
// do not loop with LCL !
|
|
if not (csDesigning in ACtl.LCLObject.ComponentState) and ACtl.InUpdate then
|
|
exit;
|
|
|
|
if ((NewSize.cx <> ACtl.LCLObject.Width) or (NewSize.cy <> ACtl.LCLObject.Height) or
|
|
ACtl.LCLObject.ClientRectNeedsInterfaceUpdate) then
|
|
ACtl.LCLObject.DoAdjustClientRectChange;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_SIZE;
|
|
Msg.SizeType := SIZE_RESTORED;
|
|
|
|
if ACtl is TGtk3Window then
|
|
begin
|
|
AState := TGtk3Window(ACtl).getWindowState;
|
|
if GDK_WINDOW_STATE_ICONIFIED in AState then
|
|
Msg.SizeType := SIZE_MINIMIZED
|
|
else
|
|
if GDK_WINDOW_STATE_MAXIMIZED in AState then
|
|
Msg.SizeType := SIZE_MAXIMIZED
|
|
else
|
|
if GDK_WINDOW_STATE_FULLSCREEN in AState then
|
|
Msg.SizeType := SIZE_FULLSCREEN;
|
|
end;
|
|
|
|
Msg.SizeType := Msg.SizeType or Size_SourceIsInterface;
|
|
|
|
Msg.Width := Word(NewSize.cx);
|
|
Msg.Height := Word(NewSize.cy);
|
|
ACtl.DeliverMessage(Msg);
|
|
end;
|
|
|
|
class function TGtk3Window.WindowMapEvent(awidget: PGtkWindow; AEvent: PGdkEventAny; adata: gpointer): gboolean; cdecl;
|
|
var
|
|
wx:gint;
|
|
wy:gint;
|
|
w:gint;
|
|
h:gint;
|
|
Alloc:TGtkAllocation;
|
|
begin
|
|
if Gtk3IsGtkWindow(aWidget) then
|
|
begin
|
|
gtk_window_get_position(aWidget, @wx, @wy);
|
|
gtk_window_get_size(aWidget, @w, @h);
|
|
end;
|
|
gtk_widget_get_allocation(aWidget, @Alloc);
|
|
//under some window managers there's discrepancy gdk window have it's default gtk size, not lcl one
|
|
//so sends 2 size-allocate events. I've introduced "lcl-window-first-map" gobject data to control
|
|
//if we are out of sync. Alloc contains correct data.
|
|
if not TGtk3Widget(AData).WidgetMapped and ((Alloc.width <> w) or (Alloc.height <> h) or (wx <> Alloc.x) or (wy <> Alloc.y)) then
|
|
begin
|
|
g_object_set_data(aWidget,'lcl-window-first-map', aData);
|
|
TGtk3Window(aData).FFirstMapRect := RectFromGdkRect(Alloc);
|
|
end;
|
|
TGtk3Widget(AData).WidgetMapped := True;
|
|
Result := gtk_false;
|
|
end;
|
|
|
|
procedure TGtk3Window.ConnectSizeAllocateSignal(ToWidget:PGtkWidget);
|
|
begin
|
|
g_signal_connect_data(ToWidget,'size-allocate',TGCallback(@WindowSizeAllocate), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(ToWidget,'map-event',TGCallback(@WindowMapEvent), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
class function TGtk3Window.decoration_flags(Aform: TCustomForm): TGdkWMDecoration;
|
|
var
|
|
icns:TBorderIcons;
|
|
bs:TFormBorderStyle;
|
|
begin
|
|
Result := [];
|
|
icns:=AForm.BorderIcons;
|
|
bs:=AForm.BorderStyle;
|
|
|
|
case bs of
|
|
bsSingle: Include(Result, GDK_DECOR_TITLE{GDK_DECOR_BORDER});
|
|
bsDialog:
|
|
Result += [GDK_DECOR_BORDER, GDK_DECOR_TITLE];
|
|
bsSizeable:
|
|
begin
|
|
if biMaximize in icns then
|
|
Include(Result, GDK_DECOR_MAXIMIZE);
|
|
if biMinimize in icns then
|
|
Include(Result, GDK_DECOR_MINIMIZE);
|
|
Result += [GDK_DECOR_BORDER, GDK_DECOR_RESIZEH, GDK_DECOR_TITLE];
|
|
end;
|
|
bsSizeToolWin:
|
|
Result += [GDK_DECOR_BORDER, GDK_DECOR_RESIZEH, GDK_DECOR_TITLE];
|
|
bsToolWindow:
|
|
Include(Result, GDK_DECOR_BORDER);
|
|
bsNone: Result := [];
|
|
end;
|
|
|
|
if GDK_DECOR_TITLE in Result then
|
|
if biSystemMenu in icns then
|
|
Include(Result, GDK_DECOR_MENU);
|
|
end;
|
|
|
|
procedure TGtk3Window.DoBeforeLCLPaint;
|
|
var
|
|
DC: TGtk3DeviceContext;
|
|
NColor: TColor;
|
|
begin
|
|
inherited DoBeforeLCLPaint;
|
|
if not Visible then
|
|
exit;
|
|
|
|
DC := TGtk3DeviceContext(Context);
|
|
|
|
NColor := LCLObject.Color;
|
|
if (NColor <> clNone) and (NColor <> clDefault) and (NColor <> clForm) then
|
|
begin
|
|
DC.CurrentBrush.Color := ColorToRGB(NColor);
|
|
DC.fillRect(0, 0, LCLObject.Width, LCLObject.Height);
|
|
end;
|
|
|
|
if BorderStyle <> bsNone then
|
|
begin
|
|
DC.CurrentPen.Color := ColorToRGB(clBtnShadow); // not sure what color to use here?
|
|
DC.drawRect(0, 0, LCLObject.Width, LCLObject.Height, False, True);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Window.ShowState(nstate:integer):boolean; // winapi ShowWindow
|
|
var
|
|
AState: TGdkWindowState;
|
|
begin
|
|
if not Gtk3IsGtkWindow(fWidget) then
|
|
exit(false);
|
|
case nstate of
|
|
SW_HIDE: PGtkWindow(FWidget)^.hide;
|
|
SW_SHOWNORMAL:
|
|
begin
|
|
AState:=fWidget^.window^.get_state;
|
|
if GDK_WINDOW_STATE_ICONIFIED in AState then
|
|
PgtkWindow(fWidget)^.deiconify
|
|
else if GDK_WINDOW_STATE_MAXIMIZED in AState then
|
|
PgtkWindow(fWidget)^.unmaximize
|
|
else if GDK_WINDOW_STATE_FULLSCREEN in AState then
|
|
PgtkWindow(fWidget)^.unfullscreen
|
|
else
|
|
PgtkWindow(fWidget)^.show;
|
|
end;
|
|
SW_SHOWMAXIMIZED: PgtkWindow(fWidget)^.maximize;
|
|
SW_MINIMIZE: PgtkWindow(fWidget)^.iconify;
|
|
SW_SHOWFULLSCREEN: PgtkWindow(fWidget)^.fullscreen;
|
|
else
|
|
PgtkWindow(fWidget)^.show;
|
|
end;
|
|
Result:=true
|
|
end;
|
|
|
|
procedure TGtk3Window.UpdateWindowState; // LCL WindowState
|
|
const
|
|
ShowCommands: array[TWindowState] of Integer =
|
|
(SW_SHOWNORMAL, SW_MINIMIZE, SW_SHOWMAXIMIZED, SW_SHOWFULLSCREEN);
|
|
begin
|
|
ShowState(ShowCommands[TCustomForm(LCLObject).WindowState]);
|
|
end;
|
|
|
|
function TGtk3Window.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AForm: TCustomForm;
|
|
decor: TGdkWMDecoration;
|
|
begin
|
|
FIcon := nil;
|
|
FFirstMapRect := Rect(0, 0, 0, 0);
|
|
|
|
FHasPaint := True;
|
|
FMenuBar := nil;
|
|
AForm := TCustomForm(LCLObject);
|
|
|
|
if not Assigned(LCLObject.Parent) then
|
|
begin
|
|
Result := TGtkWindow.new(GTK_WINDOW_TOPLEVEL);
|
|
FWidget:=Result;
|
|
//gtk_widget_realize(Result);
|
|
FWidget^.set_events(GDK_DEFAULT_EVENTS_MASK);
|
|
Title:=Params.Caption;
|
|
decor:=decoration_flags(AForm);
|
|
gtk_window_set_decorated(PGtkWindow(Result),(decor <> []));
|
|
//gdk_window_set_decorations(Result^.window, decor);
|
|
if AForm.AlphaBlend then
|
|
gtk_widget_set_opacity(Result, TForm(LCLObject).AlphaBlendValue/255);
|
|
if not gtk_window_get_decorated(PGtkWindow(Result)) then
|
|
gtk_window_set_type_hint(PGtkWindow(Result), GDK_WINDOW_TYPE_HINT_UTILITY);
|
|
FWidgetType := [wtWidget, wtLayout, wtScrollingWin, wtWindow];
|
|
end else
|
|
begin
|
|
Result := PGtkScrolledWindow(TGtkScrolledWindow.new(nil, nil));
|
|
// cannot gtk_widget_realize(Result), because that needs a valid widget parent
|
|
FWidgetType := [wtWidget, wtLayout, wtScrollingWin, wtCustomControl]
|
|
end;
|
|
Text := Params.Caption;
|
|
|
|
FBox := TGtkVBox.new(GTK_ORIENTATION_VERTICAL, 0);
|
|
|
|
FScrollWin := PGtkScrolledWindow(TGtkScrolledWindow.new(nil, nil));
|
|
g_object_set_data(FScrollWin,'lclscrollingwindow',GPointer(1));
|
|
g_object_set_data(PGObject(FScrollWin), 'lclwidget', Self);
|
|
|
|
FCentralWidget := TGtkLayout.new(nil, nil);
|
|
// FCentralWidget^.set_has_window(True);
|
|
|
|
//if AForm.AutoScroll then
|
|
FScrollWin^.add(FCentralWidget);
|
|
//else
|
|
// FScrollWin^.add_with_viewport(FCentralWidget);
|
|
|
|
FScrollWin^.show;
|
|
FBox^.pack_end(FScrollWin, True, True, 0);
|
|
FBox^.show;
|
|
|
|
FScrollWin^.get_vscrollbar^.set_can_focus(False);
|
|
FScrollWin^.get_hscrollbar^.set_can_focus(False);
|
|
FScrollWin^.set_policy(GTK_POLICY_NEVER, GTK_POLICY_NEVER);
|
|
PGtkContainer(Result)^.add(FBox);
|
|
|
|
g_signal_connect_data(Result,'window-state-event', TGCallback(@WindowStateSignal), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
g_object_set(PGObject(FCentralWidget), 'resize-mode', [GTK_RESIZE_QUEUE, nil]);
|
|
gtk_layout_set_size(PGtkLayout(FCentralWidget), 1, 1);
|
|
|
|
|
|
g_signal_connect_data(FCentralWidget,'size-allocate',TGCallback(@ScrolledLayoutSizeAllocate), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
with PGtkScrolledWindow(FScrollWin)^.get_vadjustment^ do
|
|
LCLVAdj := gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
|
|
with PGtkScrolledWindow(FScrollWin)^.get_hadjustment^ do
|
|
LCLHAdj := gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size);
|
|
|
|
gtk_widget_realize(Result);
|
|
|
|
if not Assigned(LCLObject.Parent) then
|
|
gdk_window_set_decorations(Result^.window, decor);
|
|
|
|
|
|
if not (csDesigning in AForm.ComponentState) then
|
|
UpdateWindowState;
|
|
|
|
Result^.Hide; // issue #41412
|
|
end;
|
|
|
|
function TGtk3Window.EatArrowKeys(const AKey: Word): Boolean;
|
|
begin
|
|
Result := False;
|
|
end;
|
|
|
|
function TGtk3Window.getText: String;
|
|
begin
|
|
// query widget
|
|
Result:=Title;
|
|
// return cached
|
|
if Result='' then
|
|
Result := inherited GetText;
|
|
end;
|
|
|
|
procedure TGtk3Window.setText(const AValue: String);
|
|
begin
|
|
// set cached text
|
|
inherited SetText(AValue);
|
|
// set widget text
|
|
Title := AValue;
|
|
end;
|
|
|
|
{$IFDEF GTK3DEBUGFORMS}
|
|
procedure ChildCallback(Child: PGtkWidget; Data: gpointer); cdecl;
|
|
var
|
|
Level: PtrInt;
|
|
S: string;
|
|
I:Integer;
|
|
begin
|
|
// Log the child widget type
|
|
S := '';
|
|
Level := PtrInt(Data^);
|
|
for I := 1 to Level - 1 do
|
|
S := S + ' ';
|
|
WriteLn(S + 'Found child widget of type: ', g_type_name(PGObject(Child)^.g_type_instance.g_class^.g_type));
|
|
if Gtk3IsContainer(Child) then
|
|
begin
|
|
inc(Level);
|
|
gtk_container_foreach(PGtkContainer(Child), @ChildCallback, @Level);
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
|
|
function TGtk3Window.getViewport:PGtkViewport;
|
|
var
|
|
W: PGtkWidget;
|
|
{$IFDEF GTK3DEBUGFORMS}
|
|
AInt: PtrInt;
|
|
{$ENDIF}
|
|
begin
|
|
W := FScrollWin^.get_child;
|
|
if Gtk3IsViewPort(W) then
|
|
Result := PGtkViewport(W)
|
|
else
|
|
Result := nil;
|
|
{$IFDEF GTK3DEBUGFORMS}
|
|
if Result <> nil then
|
|
writeln('TGtk3Window.GetViewport: result class is ' +g_type_name(PGObject(Result)^.g_type_instance.g_class^.g_type)+ '. Found type=',g_type_name(PGObject(W)^.g_type_instance.g_class^.g_type),' g_type=',PGObject(W)^.g_type_instance.g_class^.g_type,' g_type_is_a=',g_type_is_a(PGObject(W)^.g_type_instance.g_class^.g_type, gtk_viewport_get_type))
|
|
else
|
|
begin
|
|
writeln('TGtk3Window.GetViewport: result is nil, check if we are GtkLayout ? ',Gtk3IsLayout(W));
|
|
if Gtk3IsLayout(W) then
|
|
begin
|
|
AInt := 1;
|
|
gtk_container_foreach(PGtkContainer(W), @ChildCallback, @AInt);
|
|
end;
|
|
end;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
function TGtk3Window.getClientRect: TRect;
|
|
var
|
|
Allocation: TGtkAllocation;
|
|
R: TRect;
|
|
w: gint;
|
|
h: gint;
|
|
x: gint;
|
|
y: gint;
|
|
AViewPort: PGtkViewport;
|
|
MenuSize:Integer;
|
|
begin
|
|
AViewPort := PGtkViewPort(FCentralWidget^.get_parent);
|
|
if WidgetMapped and Gtk3IsViewPort(AViewPort) and Gtk3IsGdkWindow(AViewPort^.get_view_window) then
|
|
begin
|
|
AViewPort^.get_view_window^.get_geometry(@x, @y, @w, @h);
|
|
Result := Rect(0, 0, AViewPort^.get_view_window^.get_width, AViewPort^.get_view_window^.get_height);
|
|
// DebugLn('GetClientRect via Viewport ',dbgsName(LCLObject),' Result ',dbgs(Result));
|
|
exit;
|
|
end else
|
|
begin
|
|
if not FCentralWidget^.get_realized and not FCentralWidget^.get_mapped then
|
|
begin
|
|
// calculate our own client rect somehow.
|
|
if (LCLObject is TCustomForm) then
|
|
begin
|
|
MenuSize := 0;
|
|
if (TCustomForm(LCLObject).Menu <> nil) or (FMenuBar <> nil) then
|
|
MenuSize := GetSystemMetrics(SM_CYMENU)
|
|
else
|
|
MenuSize := 0;
|
|
Allocation.x := LCLObject.Left;
|
|
Allocation.y := LCLObject.Top;
|
|
Allocation.width := LCLObject.Width; // border
|
|
Allocation.Height := LCLObject.Height - MenuSize;
|
|
end else
|
|
begin
|
|
Allocation.X := -1;
|
|
Allocation.Y := -1;
|
|
Allocation.Width := 1;
|
|
Allocation.Height := 1;
|
|
end;
|
|
end else
|
|
FCentralWidget^.get_allocation(@Allocation);
|
|
end;
|
|
|
|
with Allocation do
|
|
R := Rect(x, y, width + x, height + y);
|
|
|
|
if IsRectEmpty(R) then
|
|
R := Rect(0, 0, 0, 0);
|
|
|
|
Result := R;
|
|
Types.OffsetRect(Result, -Result.Left, -Result.Top);
|
|
|
|
if GTK3WidgetSet.OverlayScrolling and getHorizontalScrollbar^.is_visible then
|
|
Result.Height := Result.Height - getHorizontalScrollbar^.get_allocated_height;
|
|
if GTK3WidgetSet.OverlayScrolling and getVerticalScrollbar^.is_visible then
|
|
Result.Width := Result.Width - getVerticalScrollbar^.get_allocated_width;
|
|
|
|
{$IFDEF GTK3DEBUGFORMS}
|
|
DebugLn('TGtk3Window.GetClientRect ',dbgsName(LCLObject),' Result ',dbgs(Result),' CentralWidget mapped ? ',dbgs(FCentralWidget^.get_mapped),' Realized ? ',dbgs(FCentralWidget^.get_realized));
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TGtk3Window.SetBounds(ALeft,ATop,AWidth,AHeight:integer);
|
|
var
|
|
ARect: TGdkRectangle;
|
|
Geometry: TGdkGeometry;
|
|
AHints: TGdkWindowHints;
|
|
AFixedWidthHeight: Boolean;
|
|
AForm: TCustomForm;
|
|
AMinSize, ANaturalSize: gint;
|
|
Alloc:TGtkAllocation;
|
|
x, y: gint;
|
|
begin
|
|
AForm := TCustomForm(LCLObject);
|
|
BeginUpdate;
|
|
ARect.x := ALeft;
|
|
ARect.y := ATop;
|
|
ARect.width := AWidth;
|
|
ARect.Height := AHeight;
|
|
try
|
|
{fixes gtk3 assertion}
|
|
Widget^.get_preferred_width(@AMinSize, @ANaturalSize);
|
|
Widget^.get_preferred_height(@AMinSize, @ANaturalSize);
|
|
Widget^.get_allocation(@Alloc);
|
|
{$IFDEF GTK3DEBUGFORMS}
|
|
with Alloc do
|
|
DebugLn(Format('TGtk3Window.setBounds(%d, %d, %d, %d) Natural w=%d h=%d alloc x %d y %d w %d h %d',[ALeft, ATop ,AWidth, AHeight, ANaturalSize, ANaturalSize2, x, y, width, height]));
|
|
{$ENDIF}
|
|
|
|
Widget^.size_allocate(@ARect);
|
|
if Gtk3IsGtkWindow(fWidget)
|
|
and not (csDesigning in AForm.ComponentState) {and (AForm.Parent = nil) and (AForm.ParentWindow = 0)} then
|
|
begin
|
|
AFixedWidthHeight := AForm.BorderStyle in [bsDialog, bsSingle, bsToolWindow];
|
|
with Geometry do
|
|
begin
|
|
if not AFixedWidthHeight and (AForm.Constraints.MinWidth > 0) then
|
|
min_width := AForm.Constraints.MinWidth
|
|
else
|
|
min_width := AForm.Width;
|
|
if not AFixedWidthHeight and (AForm.Constraints.MaxWidth > 0) then
|
|
max_width := AForm.Constraints.MaxWidth
|
|
else
|
|
max_width := AForm.Width;
|
|
if not AFixedWidthHeight and (AForm.Constraints.MinHeight > 0) then
|
|
min_height := AForm.Constraints.MinHeight
|
|
else
|
|
min_height := AForm.Height;
|
|
if not AFixedWidthHeight and (AForm.Constraints.MaxHeight > 0) then
|
|
max_height := AForm.Constraints.MaxHeight
|
|
else
|
|
max_height := AForm.Height;
|
|
|
|
base_width := AForm.Width;
|
|
base_height := AForm.Height;
|
|
width_inc := 1;
|
|
height_inc := 1;
|
|
min_aspect := 0;
|
|
max_aspect := 1;
|
|
win_gravity := PGtkWindow(Widget)^.get_gravity
|
|
end;
|
|
|
|
if AFixedWidthHeight then
|
|
PGtkWindow(Widget)^.set_geometry_hints(nil, @Geometry,
|
|
[GDK_HINT_POS, GDK_HINT_MIN_SIZE, GDK_HINT_MAX_SIZE])
|
|
else
|
|
begin
|
|
if AForm.BorderStyle <> bsNone then
|
|
begin
|
|
AHints := [GDK_HINT_POS, GDK_HINT_BASE_SIZE];
|
|
if (AForm.Constraints.MinHeight > 0) or (AForm.Constraints.MinWidth > 0) then
|
|
Include(AHints, GDK_HINT_MIN_SIZE);
|
|
if (AForm.Constraints.MaxHeight > 0) or (AForm.Constraints.MaxWidth > 0) then
|
|
Include(AHints, GDK_HINT_MAX_SIZE);
|
|
|
|
PGtkWindow(Widget)^.set_geometry_hints(nil, @Geometry, AHints);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
if Gtk3IsGtkWindow(FWidget) then
|
|
begin
|
|
//PGtkWindow(Widget)^.set_default_size(AWidth, AHeight);
|
|
PGtkWindow(Widget)^.set_resizable(true);
|
|
{$IF DEFINED(GTK3DEBUGCORE) OR DEFINED(GTK3DEBUGSIZE)}
|
|
writeln('Window ',dbgsName(LCLObject),' move/size ',dbgs(Bounds(ALeft, ATop, AWidth, AHeight)));
|
|
{$ENDIF}
|
|
PGtkWindow(Widget)^.resize(AWidth, AHeight);
|
|
|
|
{Must apply transient window origin here. Not sure if this is needed for decorated windows,
|
|
but non decorated with popupparent must align.}
|
|
x := 0;
|
|
y := 0;
|
|
if not PGtkWindow(Widget)^.get_decorated and (PGtkWindow(Widget)^.transient_for <> nil) then
|
|
PGtkWindow(Widget)^.transient_for^.window^.get_origin(@x, @y);
|
|
PGtkWindow(Widget)^.move(ALeft + x, ATop + y);
|
|
end;
|
|
finally
|
|
EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Window.getHorizontalScrollbar: PGtkScrollbar;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result := PGtkScrollBar(FScrollWin^.get_hscrollbar);
|
|
end;
|
|
|
|
function TGtk3Window.getVerticalScrollbar: PGtkScrollbar;
|
|
begin
|
|
Result := nil;
|
|
if not IsWidgetOk then
|
|
exit;
|
|
Result := PGtkScrollBar(FScrollWin^.get_vscrollbar);
|
|
end;
|
|
|
|
function TGtk3Window.GetScrolledWindow: PGtkScrolledWindow;
|
|
begin
|
|
if IsWidgetOK then
|
|
Result := FScrollWin
|
|
else
|
|
Result := nil;
|
|
end;
|
|
|
|
procedure TGtk3Window.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
if not IsDesigning then
|
|
begin
|
|
g_signal_connect_data(gtk_scrolled_window_get_hscrollbar(GetScrolledWindow), 'change-value',
|
|
TGCallback(@RangeChangeValue), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(gtk_scrolled_window_get_vscrollbar(GetScrolledWindow), 'change-value',
|
|
TGCallback(@RangeChangeValue), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
g_signal_connect_data(PGtkRange(gtk_scrolled_window_get_hscrollbar(GetScrolledWindow)),'value-changed',
|
|
TGCallback(@RangeValueChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(PGtkRange(gtk_scrolled_window_get_vscrollbar(GetScrolledWindow)),'value-changed',
|
|
TGCallback(@RangeValueChanged), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Window.OffsetMousePos(APoint: PPoint);
|
|
var
|
|
Hadjustment, Vadjustment: PGtkAdjustment;
|
|
HValue, VValue: longint;
|
|
begin
|
|
inherited OffsetMousePos(APoint);
|
|
// Retrieve adjustments
|
|
Hadjustment := GetScrolledWindow^.get_hadjustment;
|
|
Vadjustment := GetScrolledWindow^.get_vadjustment;
|
|
|
|
// Get the adjustment values
|
|
HValue := Round(gtk_adjustment_get_value(Hadjustment));
|
|
VValue := Round(gtk_adjustment_get_value(Vadjustment));
|
|
|
|
// Apply adjustment values to the mouse position
|
|
Dec(APoint^.x, HValue);
|
|
Dec(APoint^.y, VValue);
|
|
end;
|
|
|
|
destructor TGtk3Window.Destroy;
|
|
begin
|
|
if Gtk3IsGdkPixbuf(FIcon) then
|
|
begin
|
|
FIcon^.unref;
|
|
FIcon := nil;
|
|
end;
|
|
inherited Destroy;
|
|
end;
|
|
|
|
procedure TGtk3Window.Activate;
|
|
begin
|
|
if Gtk3IsGtkWindow(fWidget) then
|
|
begin
|
|
if Gtk3IsGdkWindow(PGtkWindow(FWidget)^.window) then
|
|
begin
|
|
PGtkWindow(FWidget)^.window^.raise_;
|
|
PGtkWindow(FWidget)^.present;
|
|
PGtkWindow(FWidget)^.activate;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3Window.ActivateWindow(AEvent: PGdkEvent);
|
|
var
|
|
MsgActivate: TLMActivate;
|
|
FIsActivated: Boolean;
|
|
begin
|
|
if not Gtk3IsGtkWindow(FWidget) then exit;
|
|
|
|
//gtk3 does not handle activate/deactivate at all
|
|
//even cannot catch it via GDK_FOCUS event ?!?
|
|
FillChar(MsgActivate{%H-}, SizeOf(MsgActivate), #0);
|
|
MsgActivate.Msg := LM_ACTIVATE;
|
|
|
|
if (AEvent <> nil) and PGtkWindow(Widget)^.is_active then
|
|
MsgActivate.Active := WA_ACTIVE
|
|
else
|
|
MsgActivate.Active := WA_INACTIVE;
|
|
MsgActivate.ActiveWindow := HWND(Self);
|
|
|
|
// DebugLn('TGtk3Window.ActivateWindow ',dbgsName(LCLObject),' Active ',dbgs(PGtkWindow(Widget)^.is_active),
|
|
// ' CustomFormActive ',dbgs(TCustomForm(LCLObject).Active));
|
|
FIsActivated := TCustomForm(LCLObject).Active;
|
|
{do not send activate if form is already activated,
|
|
also do not send activate if TCustomForm.Parent is assigned
|
|
since it's form embedded into another control or form}
|
|
if (Boolean(MsgActivate.Active) = FIsActivated) or (LCLObject.Parent <> nil) then
|
|
else
|
|
begin
|
|
// DebugLn('TGtk3Window.ActivateWindow Active ',dbgs(MsgActivate.Active = WA_ACTIVE),
|
|
// ' Message delivery to lcl ',dbgs(MsgActivate.Active));
|
|
DeliverMessage(MsgActivate);
|
|
end;
|
|
end;
|
|
|
|
function TGtk3Window.CloseQuery: Boolean;
|
|
var
|
|
Msg : TLMessage;
|
|
begin
|
|
{$IFDEF GTK3DEBUGCORE}
|
|
DebugLn('TGtk3Window.CloseQuery');
|
|
{$ENDIF}
|
|
FillChar(Msg{%H-}, SizeOf(Msg), 0);
|
|
|
|
Msg.Msg := LM_CLOSEQUERY;
|
|
|
|
DeliverMessage(Msg);
|
|
|
|
Result := False;
|
|
end;
|
|
|
|
function TGtk3Window.GetWindow: PGdkWindow;
|
|
begin
|
|
Result := FWidget^.window;
|
|
end;
|
|
|
|
function TGtk3Window.GetMenuBar: PGtkMenuBar;
|
|
var
|
|
ABox:PGtkBox;
|
|
begin
|
|
if not Assigned(FMenuBar) then
|
|
begin
|
|
FMenuBar := TGtkMenuBar.new; // our menubar (needed for main menu)
|
|
// MenuBar
|
|
// -> Menu Menu2
|
|
// Item 1 Item 3
|
|
// Item 2
|
|
g_object_set_data(Widget,'lclmenubar',GPointer(1));
|
|
ABox := PGtkBox(PGtkWindow(Widget)^.get_child);
|
|
ABox^.pack_start(FMenuBar, False, False, 0);
|
|
end;
|
|
Result := FMenuBar;
|
|
end;
|
|
|
|
function TGtk3Window.GetBox: PGtkBox;
|
|
begin
|
|
Result := FBox;
|
|
end;
|
|
|
|
function TGtk3Window.GetWindowState: TGdkWindowState;
|
|
begin
|
|
Result := [];
|
|
if IsWidgetOK and (FWidget^.get_realized) then
|
|
Result := FWidget^.window^.get_state;
|
|
end;
|
|
|
|
{ TGtk3HintWindow }
|
|
|
|
function TGtk3HintWindow.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
var
|
|
AForm: THintWindow;
|
|
begin
|
|
FText := '';
|
|
FHasPaint := True;
|
|
AForm := THintWindow(LCLObject);
|
|
|
|
FWidgetType := [wtWidget, wtContainer, wtWindow, wtHintWindow];
|
|
|
|
Result := TGtkWindow.new(GTK_WINDOW_POPUP);
|
|
|
|
FBox := TGtkVBox.new(GTK_ORIENTATION_VERTICAL, 0);
|
|
PGtkContainer(Result)^.add(FBox);
|
|
|
|
FCentralWidget := TGtkFixed.new;
|
|
|
|
FCentralWidget^.set_size_request(AForm.Width,AForm.Height+1);
|
|
|
|
FBox^.pack_start(fCentralWidget, true, true, 0);
|
|
|
|
PGtkWindow(Result)^.set_can_focus(false);
|
|
FBox^.set_can_focus(False);
|
|
FCentralWidget^.set_can_focus(False);
|
|
Result^.Hide; // issue #41412
|
|
end;
|
|
|
|
procedure TGtk3HintWindow.InitializeWidget;
|
|
var
|
|
ParentWidget: TGtk3Widget;
|
|
begin
|
|
inherited;
|
|
with LCLObject as THintWindow do begin
|
|
if HintControl is TWinControl then with HintControl as TWinControl do
|
|
begin
|
|
ParentWidget := TGtk3Widget(Handle);
|
|
FWidget^.realize;
|
|
GetWindow^.set_transient_for(ParentWidget.GetWindow);
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
{ TGtk3Dialog }
|
|
|
|
procedure TGtk3Dialog.SetCallbacks;
|
|
begin
|
|
// common callbacks for all kind of dialogs
|
|
g_signal_connect_data(fWidget,
|
|
'destroy', TGCallback(@TGtk3Dialog.DestroyCB), Self, nil, G_CONNECT_DEFAULT);
|
|
g_signal_connect_data(fWidget,
|
|
'delete-event', TGCallback(@TGtk3Dialog.CloseQueryCB), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
g_signal_connect_data(fWidget,
|
|
'response', TGCallback(@Tgtk3DIalog.ResponseCB), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
g_signal_connect_data(fWidget,
|
|
'close', TGCallback(@Tgtk3DIalog.CloseCB), Self, nil, G_CONNECT_DEFAULT);
|
|
|
|
|
|
(* g_signal_connect_data(fWidget,
|
|
'key-press-event', TGCallback(@GTKDialogKeyUpDownCB), Self, nil, 0);
|
|
g_signal_connect_data(fWidget,
|
|
'key-release-event', TGCallback(@GTKDialogKeyUpDownCB), Self, nil, 0);*)
|
|
|
|
g_signal_connect_data(fWidget,
|
|
'realize', TGCallback(@Tgtk3Dialog.RealizeCB), Self, nil, G_CONNECT_DEFAULT);
|
|
end;
|
|
|
|
class function Tgtk3Dialog.RealizeCB(dlg: TGtk3Dialog): GBoolean; cdecl;
|
|
begin
|
|
Result := False;
|
|
if (dlg=nil) then exit;
|
|
// actually key intercepion is not required
|
|
{if dlg.FWidget^.get_has_window and Gtk3IsGdkWindow(dlg.FWidget^.window) then
|
|
begin
|
|
gdk_window_set_events(dlg.FWidget^.window,
|
|
gdk_window_get_events(dlg.FWidget^.window)
|
|
or GDK_KEY_RELEASE_MASK or GDK_KEY_PRESS_MASK);
|
|
|
|
end;}
|
|
|
|
if (wtDialog in dlg.WidgetType) then
|
|
begin
|
|
if Assigned(dlg.CommonDialog) then
|
|
TCommonDialog(dlg.CommonDialog).DoShow;
|
|
end;
|
|
Result := True;
|
|
end;
|
|
|
|
|
|
class function TGtk3Dialog.DestroyCB(dlg:TGtk3Dialog): GBoolean; cdecl;
|
|
begin
|
|
Result := True;
|
|
// if (AWidget=nil) then ;
|
|
if not Assigned(dlg) then exit;
|
|
dlg.CommonDialog.UserChoice := mrCancel;
|
|
dlg.CommonDialog.Close;
|
|
end;
|
|
|
|
class function TGtk3Dialog.ResponseCB(response_id:gint; dlg: TGtk3Dialog): GBoolean; cdecl;
|
|
begin
|
|
if Assigned(dlg) then
|
|
Result:=dlg.response_handler(TGtkResponseType(response_id))
|
|
else
|
|
Result:= false;
|
|
end;
|
|
|
|
function TGtk3Dialog.response_handler(response_id:TGtkResponseType):boolean;
|
|
begin
|
|
(* case response_id of
|
|
GTK_RESPONSE_NONE:;
|
|
GTK_RESPONSE_REJECT: ;
|
|
GTK_RESPONSE_ACCEPT:;
|
|
GTK_RESPONSE_DELETE_EVENT:;
|
|
GTK_RESPONSE_OK:;
|
|
GTK_RESPONSE_CANCEL:;
|
|
GTK_RESPONSE_CLOSE:;
|
|
GTK_RESPONSE_YES:;
|
|
GTK_RESPONSE_NO:;
|
|
GTK_RESPONSE_APPLY:;
|
|
GTK_RESPONSE_HELP:;
|
|
end;*)
|
|
if response_id=GTK_RESPONSE_YES then
|
|
begin
|
|
Self.CommonDialog.UserChoice:=mrYes;
|
|
end else
|
|
if response_id=GTK_RESPONSE_NO then
|
|
begin
|
|
Self.CommonDialog.UserChoice:=mrNo;
|
|
end else
|
|
if response_id=GTK_RESPONSE_OK then
|
|
begin
|
|
Self.CommonDialog.UserChoice:=mrOk;
|
|
end else
|
|
if response_id=GTK_RESPONSE_CANCEL then
|
|
begin
|
|
Self.CommonDialog.UserChoice:=mrCancel;
|
|
end else
|
|
if response_id=GTK_RESPONSE_CLOSE then
|
|
begin
|
|
Self.CommonDialog.UserChoice:=mrClose;
|
|
end;
|
|
Result:=false;
|
|
end;
|
|
|
|
function TGtk3Dialog.close_handler(): boolean;
|
|
begin
|
|
Result:=false;
|
|
end;
|
|
|
|
class function TGtk3Dialog.CloseCB(dlg: TGtk3Dialog): GBoolean;
|
|
cdecl;
|
|
begin
|
|
if Assigned(dlg) then
|
|
Result:=dlg.close_handler()
|
|
else
|
|
Result:= true;
|
|
end;
|
|
|
|
class function TGtk3Dialog.CloseQueryCB(w:PGtkWidget;dlg:TGtk3Dialog): GBoolean;
|
|
cdecl;
|
|
var
|
|
theDialog : TCommonDialog;
|
|
CanClose: boolean;
|
|
//AHandle: HWND;
|
|
begin
|
|
Result := False; // true = do nothing, false = destroy or hide window
|
|
if (dlg=nil) then exit;
|
|
// data is not the commondialog. Get it manually.
|
|
// AHandle := HwndFromGtkWidget(AWidget);
|
|
if (dlg <> nil) and (wtDialog in TGtk3Widget(dlg).WidgetType) then
|
|
begin
|
|
theDialog := dlg.CommonDialog;
|
|
if theDialog = nil then exit;
|
|
if theDialog.OnCanClose<>nil then
|
|
begin
|
|
CanClose:=True;
|
|
theDialog.DoCanClose(CanClose);
|
|
Result := not CanClose;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
|
|
|
|
function TGtk3Dialog.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
FWidgetType := [wtWidget, wtDialog];
|
|
Result := TGtkDialog.new;
|
|
DebugLn('WARNING: TGtk3Dialog.CreateWidget should be used in real dialog constructor .');
|
|
end;
|
|
|
|
procedure TGtk3Dialog.InitializeWidget;
|
|
begin
|
|
g_object_set_data(FWidget,'lclwidget', Self);
|
|
end;
|
|
|
|
procedure TGtk3Dialog.CloseDialog;
|
|
begin
|
|
if fWidget<>nil then
|
|
fWidget^.destroy_;
|
|
end;
|
|
|
|
|
|
{ TGtk3FileDialog }
|
|
|
|
function TGtk3FileDialog.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
DebugLn('ERROR: TGtk3FileDialog.CreateWidget error.');
|
|
// Result := nil;
|
|
Result := TGtkFileChooserDialog.new;
|
|
// gtk_file_chooser_dialog_new();
|
|
end;
|
|
|
|
constructor TGtk3FileDialog.Create(const ACommonDialog: TCommonDialog);
|
|
|
|
var
|
|
FileDialog: TFileDialog absolute ACommonDialog;
|
|
Action: TGtkFileChooserAction;
|
|
Button1: String;
|
|
AFileDialog: PGtkFileChooserDialog;
|
|
AParams: TCreateParams;
|
|
begin
|
|
inherited Create;
|
|
FOwnWidget := True;
|
|
// Initializes the properties
|
|
FKeysToEat := [VK_TAB, VK_RETURN, VK_ESCAPE];
|
|
FWidgetType := [wtWidget, wtDialog];
|
|
|
|
// FHasPaint := False;
|
|
CommonDialog := ACommonDialog;
|
|
// Defines an action for the dialog and creates it
|
|
Action := GTK_FILE_CHOOSER_ACTION_OPEN;
|
|
Button1 := GTK_STOCK_OPEN;
|
|
|
|
if (FileDialog is TSaveDialog) or (FileDialog is TSavePictureDialog) then
|
|
begin
|
|
Action := GTK_FILE_CHOOSER_ACTION_SAVE;
|
|
Button1 := GTK_STOCK_SAVE;
|
|
end
|
|
else
|
|
if FileDialog is TSelectDirectoryDialog then
|
|
Action := GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
|
|
|
|
FWidget := gtk_file_chooser_dialog_new(PgChar(FileDialog.Title), nil,
|
|
Action, PChar(GTK_STOCK_CANCEL),
|
|
[GTK_RESPONSE_CANCEL, PChar(Button1), GTK_RESPONSE_OK, nil]);
|
|
|
|
AFileDialog := PGtkFileChooserDialog(FWidget);
|
|
if FileDialog is TSaveDialog then
|
|
begin
|
|
gtk_file_chooser_set_do_overwrite_confirmation(PGtkFileChooser(AFileDialog),
|
|
ofOverwritePrompt in TOpenDialog(FileDialog).Options);
|
|
end;
|
|
|
|
if FileDialog.InitialDir <> '' then
|
|
gtk_file_chooser_set_current_folder(PGtkFileChooser(AFileDialog), Pgchar(FileDialog.InitialDir));
|
|
|
|
if gtk_file_chooser_get_action(PGtkFileChooser(AFileDialog)) in
|
|
[GTK_FILE_CHOOSER_ACTION_SAVE, GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER]
|
|
then
|
|
gtk_file_chooser_set_current_name(PGtkFileChooser(AFileDialog), Pgchar(FileDialog.FileName));
|
|
|
|
InitializeWidget;
|
|
end;
|
|
|
|
{ TGtk3FontSelectionDialog }
|
|
|
|
procedure TGtk3FontSelectionDialog.InitializeWidget;
|
|
var
|
|
fnt:TFont;
|
|
pch:PgtkFontChooser;
|
|
fontDesc: PPangoFontDescription;
|
|
family: String;
|
|
stretch: TPangoStretch;
|
|
weight: TPangoWeight;
|
|
begin
|
|
fWidget:=TGtkFontChooserDialog.new(PChar(CommonDialog.Title),nil);
|
|
fontDesc := TPangoFontDescription.new;
|
|
try
|
|
fnt:=TFontDialog(CommonDialog).Font;
|
|
if fnt.Size = 0 then
|
|
FontDesc^.set_size(10 * PANGO_SCALE)
|
|
else
|
|
FontDesc^.set_size(fnt.Size * PANGO_SCALE);
|
|
|
|
family := fnt.Name;
|
|
ExtractPangoFontFaceSuffixes(family, stretch, weight);
|
|
fontDesc^.set_family(PChar(family));
|
|
|
|
if (fsBold in fnt.Style) and (weight < PANGO_WEIGHT_SEMIBOLD) then
|
|
// bold is specified by the fsBold flag only
|
|
fontDesc^.set_weight(PANGO_WEIGHT_BOLD)
|
|
else
|
|
fontDesc^.set_weight(weight);
|
|
|
|
if fsItalic in fnt.Style then
|
|
begin
|
|
// we need to specify the exact style for the font dialog
|
|
if PangoFontHasItalicFace(fWidget^.get_pango_context, family) then
|
|
fontDesc^.set_style(PANGO_STYLE_ITALIC)
|
|
else
|
|
fontDesc^.set_style(PANGO_STYLE_OBLIQUE);
|
|
end
|
|
else
|
|
fontDesc^.set_style(PANGO_STYLE_NORMAL);
|
|
|
|
if (stretch = PANGO_STRETCH_NORMAL) then
|
|
fontDesc^.set_stretch(GetPangoFontDefaultStretch(family))
|
|
else
|
|
fontDesc^.set_stretch(stretch);
|
|
|
|
pch:=PGtkFontChooser(fWidget);
|
|
pch^.set_font_desc(fontDesc);
|
|
finally
|
|
fontDesc^.free;
|
|
end;
|
|
inherited InitializeWidget;
|
|
end;
|
|
|
|
function TGtk3FontSelectionDialog.response_handler(resp_id: TGtkResponseType): boolean;
|
|
var
|
|
fnt:TFont;
|
|
pch:PgtkFontChooser;
|
|
pfc:PPangoFontFace;
|
|
pfd:PPangoFontDescription;
|
|
fnts:TfontStyles;
|
|
family: Pgchar;
|
|
begin
|
|
if resp_id=GTK_RESPONSE_OK then
|
|
begin
|
|
fnt:=TFontDialog(CommonDialog).Font;
|
|
pch:=PGtkFontChooser(fWidget);
|
|
pfc:=pch^.get_font_face();
|
|
pfd:=pfc^.describe;
|
|
{ this stuff is implemened in gtk3objects.Tgtk3Font.UpdateLogFont
|
|
so this is backward mapping of properties }
|
|
|
|
family := pfd^.get_family();
|
|
fnt.Name:=AppendPangoFontFaceSuffixes(family, pfd^.get_stretch, pfd^.get_weight);
|
|
fnt.Size:=pch^.get_font_size() div PANGO_SCALE;
|
|
|
|
fnts:=[];
|
|
if pfd^.get_weight >= PANGO_WEIGHT_SEMIBOLD then
|
|
include(fnts,fsBold);
|
|
|
|
// do not differentiate oblique and italic
|
|
if (pfd^.get_style >= PANGO_STYLE_OBLIQUE) then
|
|
include(fnts,fsItalic);
|
|
fnt.Style:=fnts;
|
|
end;
|
|
Result:=inherited response_handler(resp_id);
|
|
end;
|
|
|
|
constructor TGtk3FontSelectionDialog.Create(const ACommonDialog: TCommonDialog);
|
|
begin
|
|
inherited Create;
|
|
FOwnWidget := True;
|
|
// Initializes the properties
|
|
FKeysToEat := [VK_TAB, VK_RETURN, VK_ESCAPE];
|
|
FWidgetType := [wtWidget, wtDialog];
|
|
|
|
// FHasPaint := False;
|
|
CommonDialog := ACommonDialog;
|
|
InitializeWidget;
|
|
Self.SetCallbacks;
|
|
end;
|
|
|
|
{ TGtk3ColorSelectionDialog }
|
|
|
|
procedure TGtk3ColorSelectionDialog.InitializeWidget;
|
|
var
|
|
clr:TColor;
|
|
rgba:TGdkRGBA;
|
|
begin
|
|
fWidget := TGtkColorSelectionDialog.new(PChar(Self.CommonDialog.Title));
|
|
clr:=ColorToRgb(TColorDialog(Self.CommonDialog).Color);
|
|
rgba.red:=Red(clr)/255;
|
|
rgba.blue:=Blue(clr)/255;
|
|
rgba.green:=Green(clr)/255;
|
|
rgba.alpha:=(clr shl 24)/255;
|
|
gtk_color_selection_set_current_rgba (
|
|
PgtkColorSelection(PGtkColorSelectionDialog(fWidget)^.color_selection),
|
|
@rgba);
|
|
end;
|
|
|
|
constructor TGtk3ColorSelectionDialog.Create(const ACommonDialog: TCommonDialog
|
|
);
|
|
begin
|
|
inherited Create;
|
|
FOwnWidget := True;
|
|
// Initializes the properties
|
|
FKeysToEat := [VK_TAB, VK_RETURN, VK_ESCAPE];
|
|
FWidgetType := [wtWidget, wtDialog];
|
|
|
|
// FHasPaint := False;
|
|
CommonDialog := ACommonDialog;
|
|
TGtk3Widget(Self).InitializeWidget;
|
|
Self.SetCallbacks;
|
|
end;
|
|
|
|
|
|
{ TGtk3newColorSelectionDialog }
|
|
|
|
procedure TGtk3newColorSelectionDialog.InitializeWidget;
|
|
var
|
|
rgba:TGdkRGBA;
|
|
dlg:TColorDialog;
|
|
begin
|
|
dlg:=TColorDialog(CommonDialog);
|
|
fWidget:= TGtkColorChooserDialog.new(PChar(Self.CommonDialog.Title), nil);
|
|
self.color_to_rgba(dlg.Color, rgba);
|
|
PGtkColorChooser(fWidget)^.use_alpha:=(cdShowAlphaChannel in dlg.Options);
|
|
if (cdPreventFullOpen in dlg.Options) then // drop basic palette that way
|
|
PGtkColorChooser(fWidget)^.add_palette(GTK_ORIENTATION_HORIZONTAL,9,10,nil);
|
|
PGtkColorChooser(fWidget)^.set_rgba(@rgba);
|
|
inherited;
|
|
end;
|
|
|
|
function TGtk3newColorSelectionDialog.response_handler(resp_id: TGtkResponseType): boolean;
|
|
var
|
|
clr:TColor;
|
|
rgba:TGdkRGBA;
|
|
begin
|
|
if resp_id=GTK_RESPONSE_OK then
|
|
begin
|
|
PGtkColorChooser(fWidget)^.get_rgba(@rgba);
|
|
clr:=self.rgba_to_color(rgba);
|
|
if not PGtkColorChooser(fWidget)^.use_alpha then
|
|
clr:=clr and $00ffffff;
|
|
TColorDialog(Self.CommonDialog).Color:=clr;
|
|
end;
|
|
Result:=inherited response_handler(resp_id);
|
|
end;
|
|
|
|
constructor TGtk3newColorSelectionDialog.Create(const ACommonDialog: TCommonDialog
|
|
);
|
|
begin
|
|
inherited Create;
|
|
FOwnWidget := True;
|
|
// Initializes the properties
|
|
LCLObject := nil;
|
|
FKeysToEat := [VK_TAB, VK_RETURN, VK_ESCAPE];
|
|
FWidgetType := [wtWidget, wtDialog];
|
|
|
|
// FHasPaint := False;
|
|
CommonDialog := ACommonDialog;
|
|
TGtk3Widget(Self).InitializeWidget;
|
|
Self.SetCallbacks;
|
|
end;
|
|
|
|
class procedure TGtk3newColorSelectionDialog.color_to_rgba(clr: TColor; out
|
|
rgba: TgdkRGBA);
|
|
begin
|
|
rgba := TColortoTGdkRGBA(clr);
|
|
end;
|
|
|
|
class function TGtk3newColorSelectionDialog.rgba_to_color(const rgba: TgdkRGBA
|
|
): TColor;
|
|
begin
|
|
Result := TGdkRGBAToTColor(rgba);
|
|
end;
|
|
|
|
|
|
{ TGtk3GLArea }
|
|
|
|
procedure TGtk3GLArea.Update(ARect: PRect);
|
|
begin
|
|
if IsWidgetOK then
|
|
PGtkGLArea(Widget)^.queue_render;
|
|
end;
|
|
|
|
function TGtk3GLArea.CreateWidget(const Params: TCreateParams): PGtkWidget;
|
|
begin
|
|
FWidgetType := [wtWidget, wtGLArea];
|
|
Result := TGtkGLArea.new;
|
|
end;
|
|
|
|
{ TGtk3DesignWidget }
|
|
|
|
procedure TGtk3DesignWidget.BringDesignerToFront;
|
|
begin
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
writeln('>BringDesignerToFront ');
|
|
{$ENDIF}
|
|
if Gtk3IsGdkWindow(getContainerWidget^.window) then
|
|
getContainerWidget^.window^.raise_;
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
writeln('<BringDesignerToFront ');
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure TGtk3DesignWidget.ResizeDesigner;
|
|
var
|
|
R: TGdkRectangle;
|
|
begin
|
|
// Design control must be same as form area,
|
|
gtk_widget_get_allocation(getContainerWidget, @R);
|
|
with R do
|
|
begin
|
|
//gtk_widget_set_allocation(FDesignControl, @R);
|
|
//gtk_widget_queue_resize(FDesignControl);
|
|
end;
|
|
end;
|
|
|
|
function Gtk3DrawDesigner(AWidget: PGtkWidget; AContext: Pcairo_t; Data: gpointer): gboolean; cdecl;
|
|
var
|
|
ARect: TGdkRectangle;
|
|
begin
|
|
Result := False;
|
|
if Data <> nil then
|
|
begin
|
|
gdk_cairo_get_clip_rectangle(AContext, @ARect);
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
writeln('>Gtk3DrawDesigner ');
|
|
{$ENDIF}
|
|
Result := TGtk3DesignWidget(Data).GtkEventPaint(AWidget, AContext);
|
|
// workaround for lcl painted widgets until we found why gtk3 sends wrong rect
|
|
// if (TGtk3Widget(Data).FHasPaint) and
|
|
if (ARect.height < (TGtk3DesignWidget(Data).getContainerWidget^.get_allocated_height div 4) ) then
|
|
begin
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
with ARect do
|
|
writeln('Queued new draw for designer ?!? x=',x,' y=',y,' w=',width,' h=',height);
|
|
{$ENDIF}
|
|
//do not queue any draw for now
|
|
//with ARect do
|
|
// AWidget^.queue_draw_area(x, y , width, height);
|
|
end;
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
writeln('<Gtk3DrawDesigner ');
|
|
{$ENDIF}
|
|
end;
|
|
end;
|
|
|
|
function TGtk3DesignWidget.CreateWidget(const Params: TCreateParams
|
|
): PGtkWidget;
|
|
begin
|
|
Result := inherited CreateWidget(Params);
|
|
gtk_widget_set_has_window(Widget, True);
|
|
gtk_widget_set_has_window(GetContainerWidget, True);
|
|
end;
|
|
|
|
function TGtk3DesignWidget.GetContext: HDC;
|
|
begin
|
|
if FDesignContext <> 0 then
|
|
Result := FDesignContext
|
|
else
|
|
Result := inherited GetContext;
|
|
end;
|
|
|
|
procedure TGtk3DesignWidget.InitializeWidget;
|
|
begin
|
|
inherited InitializeWidget;
|
|
g_signal_handler_disconnect(getContainerWidget, FDrawSignal);
|
|
g_signal_connect_data(getContainerWidget,'draw', TGCallback(@Gtk3DrawDesigner), Self, nil, G_CONNECT_DEFAULT);
|
|
BringDesignerToFront;
|
|
end;
|
|
|
|
function TGtk3DesignWidget.GtkEventPaint(Sender: PGtkWidget; AContext: Pcairo_t
|
|
): Boolean; cdecl;
|
|
var
|
|
Msg: TLMPaint;
|
|
AStruct: TPaintStruct;
|
|
AClipRect: TGdkRectangle;
|
|
localClip:TRect;
|
|
P: TPoint;
|
|
begin
|
|
Result := gtk_false;
|
|
|
|
if not FHasPaint then
|
|
exit;
|
|
|
|
FillChar(Msg{%H-}, SizeOf(Msg), #0);
|
|
|
|
Msg.Msg := LM_PAINT;
|
|
|
|
FillChar(AStruct{%H-}, SizeOf(TPaintStruct), 0);
|
|
Msg.PaintStruct := @AStruct;
|
|
|
|
with PaintData do
|
|
begin
|
|
if GetContainerWidget = nil then
|
|
PaintWidget := Widget
|
|
else
|
|
PaintWidget := GetContainerWidget;
|
|
ClipRegion := nil;
|
|
gdk_cairo_get_clip_rectangle(AContext, @AClipRect);
|
|
localClip:=RectFromGdkRect(AClipRect);
|
|
ClipRect := @localClip;
|
|
end;
|
|
FContext := 0;
|
|
FCairoContext := AContext;
|
|
Msg.DC := BeginPaint(HWND(Self), AStruct);
|
|
FDesignContext := Msg.DC;
|
|
FContext := Msg.DC;
|
|
Msg.PaintStruct^.rcPaint := PaintData.ClipRect^;
|
|
Msg.PaintStruct^.hdc := FDesignContext;
|
|
|
|
P := getClientOffset;
|
|
TGtk3DeviceContext(Msg.DC).translate(P);
|
|
try
|
|
try
|
|
//DoBeforeLCLPaint;
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
writeln('>TGtk3DesignWidget.Paint DC=',dbgHex(Msg.DC),' offset=',dbgs(P),' surface=',cairo_surface_get_type(cairo_get_target(AContext)));
|
|
{$ENDIF}
|
|
LCLObject.WindowProc(TLMessage(Msg));
|
|
{$IFDEF GTK3DEBUGDESIGNER}
|
|
writeln('<TGtk3DesignWidget.Paint');
|
|
{$ENDIF}
|
|
finally
|
|
FCairoContext := nil;
|
|
Fillchar(FPaintData, SizeOf(FPaintData), 0);
|
|
FContext := 0;
|
|
FDesignContext := 0;
|
|
EndPaint(HWND(Self), AStruct);
|
|
end;
|
|
except
|
|
Application.HandleException(nil);
|
|
end;
|
|
end;
|
|
|
|
procedure TGtk3DesignWidget.lowerWidget;
|
|
begin
|
|
inherited lowerWidget;
|
|
BringDesignerToFront;
|
|
end;
|
|
|
|
procedure TGtk3DesignWidget.raiseWidget;
|
|
begin
|
|
inherited raiseWidget;
|
|
BringDesignerToFront;
|
|
end;
|
|
|
|
end.
|
|
|