mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-10-31 07:31:49 +01:00
1499 lines
58 KiB
TeX
1499 lines
58 KiB
TeX
\documentclass[10pt]{article}
|
|
\usepackage{a4}
|
|
\usepackage{epsfig}
|
|
\usepackage{listings}
|
|
\usepackage{tabularx}
|
|
\lstset{language=Delphi}%
|
|
\lstset{basicstyle=\sffamily\small}%
|
|
\lstset{commentstyle=\itshape}%
|
|
\lstset{keywordstyle=\bfseries}%
|
|
\lstset{blankstring=true}%
|
|
\newcommand{\file}[1]{\textsf{#1}}
|
|
\usepackage[pdftex]{hyperref}
|
|
\newif\ifpdf
|
|
\ifx\pdfoutput\undefined
|
|
\pdffalse
|
|
\else
|
|
\pdfoutput=1
|
|
\pdftrue
|
|
\fi
|
|
\begin{document}
|
|
\title{Programming GTK in Free Pascal: Making a real-world application.}
|
|
\author{Florian Kl\"ampfl\\and\\Micha\"el Van Canneyt}
|
|
\date{January 2001}
|
|
\maketitle
|
|
\section{Introduction}
|
|
In the third article on programming the GTK toolkit, the use of several
|
|
GTK widgets is demonstrated by building a real-world application.
|
|
|
|
The main widgets to be shown are the Toolbar, CList and Tree widgets.
|
|
Along the way, some other widgets such as a dialog will be shown as well.
|
|
|
|
The program to show all this will be a small file explorer. It will not
|
|
perform all functions that one would expect from a file explorer, but it
|
|
is not meant to be, either. It just demonstrates how one could go about when
|
|
making a file explorer.
|
|
|
|
The File explorer will have 2 main components. One is a directory tree
|
|
which can be used to select a directory. the other is a Clist, a component
|
|
that presents a list of items in a table with headings. The Clist will be
|
|
used to display the files in the directory selected in the directory tree.
|
|
|
|
The functionality included will be limited to viewing the properties of
|
|
a file, and deleting a file. The view can be customized, and sorting of
|
|
columns by clicking the column header is possible.
|
|
|
|
Each window developed in the article will be described in a record, i.e.
|
|
all window elements will have a field in a record that points to the
|
|
GTK widget used. Several forms will be developed, and each form will be
|
|
put in a separate unit. Signal callbacks will in general receive a
|
|
'userdata' pointer that points to the window record. This approach mimics
|
|
the object oriented approach of GTK, and is similar to the approach in
|
|
Delphi, where instead of a object, a window class is used.
|
|
|
|
\section{The main window}
|
|
The main window will consist of a menu, a tool bar, a directory tree and
|
|
the file list. The bottom of the screen will contain a statusbar. Between
|
|
the directory tree and the file list is a splitter that can be used to
|
|
resize the directory tree.
|
|
|
|
Right-clicking on the file list will show a popup menu, from which file
|
|
actions can be selected.
|
|
|
|
All the widgets in the main window will be stored in a big record
|
|
\lstinline|TMainWindow|:
|
|
\begin{lstlisting}{}
|
|
TMainWindow = Record
|
|
FDir,
|
|
FMask : String;
|
|
Window : PGtkWindow;
|
|
Menu : PGtkMenuBar;
|
|
Toolbar : PGtkToolBar;
|
|
DirTree : PGtkTree;
|
|
FileList : PGtkClist;
|
|
Pane : PGtkPaned;
|
|
StatusBar : PGtkStatusBar;
|
|
FilesHeader,DirHeader : PGtkLabel;
|
|
// helper objects - Menu
|
|
Accel : PGtkAccelGroup;
|
|
MFile,
|
|
MView,
|
|
MColumns,
|
|
MHelp,
|
|
// Main menu items
|
|
PMFiles : PGtkMenu;
|
|
MIFile,
|
|
MIFileProperties,
|
|
MIFileDelete,
|
|
MIExit,
|
|
MiColumns,
|
|
MIAbout,
|
|
MIHelp : PGtkMenuItem;
|
|
MIShowTitles,
|
|
MIShowExt,
|
|
MIShowSize,
|
|
MiShowDate,
|
|
MIShowAttrs : PGtkCheckMenuItem;
|
|
// Files PopupMenu Items:
|
|
PMIFileProperties,
|
|
PMIFileDelete : PGtkMenuItem;
|
|
// Packing boxes
|
|
VBox,
|
|
LeftBox,
|
|
RightBox : PGtkBox;
|
|
// Scroll boxes
|
|
TreeScrollWindow,
|
|
ListScrollWindow : PGtkScrolledWindow;
|
|
// Tree root node.
|
|
RootNode : PGtkTreeItem;
|
|
end;
|
|
PMainWindow = ^TMainWindow;
|
|
\end{lstlisting}
|
|
The record resembles a form class definition as used in \lstinline|Delphi|, it
|
|
contains all possible widgets shown on the window.
|
|
|
|
The most important ones are of course the \lstinline|DirTree| and \lstinline|FileList|
|
|
fields, the \lstinline|Menu| which will refer to the main menu and the
|
|
\lstinline|PMfiles| which will hold the popup menu. The Status bar is of course
|
|
in the \lstinline|StatusBar| field, and the \lstinline|ToolBar| field will hold the main
|
|
toolbar of the application.
|
|
|
|
The \lstinline|FDir| field will be used to hold the currently shown
|
|
directory and the \lstinline|FMask| field can be used to store a file mask that
|
|
determines what files will be shown in the list.
|
|
|
|
All these fields are filled in using the function \lstinline|NewMainForm| :
|
|
\begin{lstlisting}{}
|
|
Function NewMainForm : PMainWindow;
|
|
\end{lstlisting}
|
|
|
|
The function starts as follows :
|
|
\begin{lstlisting}{}
|
|
begin
|
|
Result:=New(PMainWindow);
|
|
With Result^ do
|
|
begin
|
|
FMask:='*.*';
|
|
Window:=PgtkWindow(gtk_window_new(GTK_WINDOW_TOPLEVEL));
|
|
gtk_window_set_title(Window,SFileExplorer);
|
|
gtk_widget_set_usize(PgtkWidget(Window),640,480);
|
|
gtk_signal_connect (PGTKOBJECT (window), 'destroy',
|
|
GTK_SIGNAL_FUNC (@destroy), Result);
|
|
gtk_widget_realize(PgtkWidget(window));
|
|
\end{lstlisting}
|
|
This is a more or less standard GTK setup for a window. Note that the
|
|
pointer to the window record is passed to the 'destroy' signal handler
|
|
for the window, and that the window widget is realized (so a actual
|
|
window is created). The necessity for the 'realize' call is explained below.
|
|
|
|
After the window is created, the main widgets on the form are created:
|
|
\begin{lstlisting}{}
|
|
Menu:=NewMainMenu(Result);
|
|
ToolBar:=NewToolbar(Result);
|
|
StatusBar:=PgtkStatusBar(gtk_statusbar_new);
|
|
FileList:=NewFileList(Result);
|
|
DirTree:=NewDirtree(Result);
|
|
PMFiles:=NewFilePopupMenu(Result);
|
|
\end{lstlisting}
|
|
|
|
The functions used to create these widgets will be discussed further on.
|
|
\begin{description}
|
|
\item[Menu] The menu is created in the function \lstinline|NewMainMenu|
|
|
\item[ToolBar] The toolbar is created in the \lstinline|NewToolbar| function.
|
|
\item[FileList] The CList component which will show the file data. Created
|
|
using \lstinline|NewFileList|.
|
|
\item[DirTree] The directory tree showing the directory structure of the
|
|
disk is created using \lstinline|NewDirtree|.
|
|
\item[PMFiles] is the popup menu for the file list and is created in the
|
|
\lstinline|NewFilePopupMenu| function.
|
|
\end{description}
|
|
Each function will set the fields which contain the helper widgets.
|
|
|
|
After the main widgets have been created, it is time to put them on the
|
|
form, and the rest of the \lstinline|NewMainForm| function is concerned
|
|
mainly with placing the widgets in appropriate containers.
|
|
|
|
A splitter widget in GTK is called a \lstinline|paned window|. It can be created
|
|
using one of the following functions:
|
|
\begin{lstlisting}{}
|
|
function gtk_hpaned_new : PGtkWidget;
|
|
function gtk_vpaned_new : PGtkWidget;
|
|
\end{lstlisting}
|
|
Since the directory tree and file explorer window will be located left to
|
|
each other, a \lstinline|gtk_hpaned_new| call is needed for the file explorer.
|
|
|
|
The \lstinline|paned window| has 2 halves, in each of which a widget can be
|
|
placed. This is done using the following calls:
|
|
\begin{lstlisting}{}
|
|
procedure gtk_paned_add1(paned:PGtkPaned; child:PGtkWidget);cdecl;
|
|
procedure gtk_paned_add2(paned:PGtkPaned; child:PGtkWidget);cdecl;
|
|
\end{lstlisting}
|
|
The first function adds a widget to the left pane, the second to the right
|
|
pane (or the top and bottom panes if the splitter is vertical).
|
|
|
|
With this knowledge, the Directory Tree and File List can be put on the
|
|
form. In the case of the file explorer, 2 widgets will be packed in vertical
|
|
boxes which are on their turn put the left and right panes of the splitter:
|
|
\begin{lstlisting}{}
|
|
Pane:=PgtkPaned(gtk_hpaned_new);
|
|
DirHeader:=PgtkLabel(gtk_label_new(pchar(SDirTree)));
|
|
LeftBox:=PGtkBox(gtk_vbox_new(false,0));
|
|
gtk_box_pack_start(Leftbox,PGtkWidget(DirHeader),False,False,0);
|
|
gtk_box_pack_start(Leftbox,PgtkWidget(TreeScrollWindow),true,True,0);
|
|
gtk_paned_add1(pane,PGtkWidget(Leftbox));
|
|
\end{lstlisting}
|
|
The left-hand side vertical box (\lstinline|LeftBox|) contains a label
|
|
(\lstinline|DirHeader|) which serves as a heading for the directory tree (\lstinline|DirTree|).
|
|
It displays a static text (in the constant \lstinline|SDirTree|).
|
|
|
|
The right pane can be filled in a similar way with the file list:
|
|
\begin{lstlisting}{}
|
|
FilesHeader:=PgtkLabel(gtk_label_new(pchar(SFilesInDir)));
|
|
RightBox:=PGtkBox(gtk_vbox_new(false,0));
|
|
gtk_box_pack_start(Rightbox,PGtkWidget(FilesHeader),False,False,0);
|
|
gtk_box_pack_start(Rightbox,PGtkWidget(ListScrollWindow),true,True,0);
|
|
gtk_paned_add2(pane,PGtkWidget(Rightbox));
|
|
\end{lstlisting}
|
|
The right-hand side vertical box contains a label \lstinline|FileHeader|
|
|
which serves as a heading for the file list (\lstinline|FileList|).
|
|
It will be used to display the current directory name
|
|
(\lstinline|SFilesInDir| constant).
|
|
|
|
After the directory tree and file view have been put in a paned window,
|
|
all that is left to do is to stack the statusbar, paned window, toolbar
|
|
and menu in a vertical box \lstinline|VBox| which covers the whole window:
|
|
\begin{lstlisting}{}
|
|
VBox:=PGtkBox(gtk_vbox_new(false,0));
|
|
gtk_container_add(PGtkContainer(Window),PgtkWidget(VBox));
|
|
gtk_box_pack_start(vbox,PGtkWidget(Menu),False,False,0);
|
|
gtk_box_pack_start(vbox,PGtkWidget(ToolBar),False,False,0);
|
|
gtk_box_pack_start(vbox,PGtkWidget(Pane),true,true,0);
|
|
gtk_box_pack_start(vbox,PGtkWidget(StatusBar),false,false,0);
|
|
gtk_widget_show_all(PGtkWidget(vbox));
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
The destroy signal of the window does nothing except destroying the
|
|
main window record and telling GTK to exit the event loop:
|
|
\begin{lstlisting}{}
|
|
procedure destroy(widget : pGtkWidget ; Window : PMainWindow); cdecl;
|
|
begin
|
|
gtk_clist_clear(Window^.FileList);
|
|
dispose(Window);
|
|
gtk_main_quit();
|
|
end;
|
|
\end{lstlisting}
|
|
The call to \lstinline|gtk_clist_clear| serves to clear the file list window.
|
|
The necessity for this call will be explained below.
|
|
|
|
\section{The file list}
|
|
The file list is constructed using the GTK CList widget. This is a powerful
|
|
widget that contains a lot of functionality, comparable to the
|
|
\lstinline|TListView| component found in Delphi.
|
|
|
|
A the file list widget is created using the following function:
|
|
\begin{lstlisting}{}
|
|
Function NewFileList(MainWindow : PMainWindow) : PGtkClist;
|
|
|
|
Const
|
|
Titles : Array[1..6] of pchar =
|
|
('Name','ext','Size','Date','Attributes','');
|
|
|
|
begin
|
|
MainWindow^.ListScrollWindow:=
|
|
PGtkScrolledWindow(gtk_scrolled_window_new(Nil,Nil));
|
|
gtk_scrolled_window_set_policy(MainWindow^.ListScrollWindow,
|
|
GTK_POLICY_AUTOMATIC,
|
|
GTK_POLICY_AUTOMATIC);
|
|
Result:=PGtkClist(Gtk_Clist_New_with_titles(6,@Titles));
|
|
gtk_Container_add(PGTKContainer(MainWindow^.ListScrollWindow),
|
|
PGtkWidget(Result));
|
|
\end{lstlisting}
|
|
A Clist object is not capable of drawing scroll bars if it contains too many
|
|
items for its size, so first a \lstinline|Scrolled Window| is created in which
|
|
the Clist object is embedded. A scrolled window is a container widget which
|
|
does nothing except providing scrollbars for the widget it contains.
|
|
|
|
A scrolled window is created using the \lstinline|gtk_scrolled_window_new|
|
|
function:
|
|
\begin{lstlisting}{}
|
|
function gtk_scrolled_window_new(hadjustment:PGtkAdjustment;
|
|
vadjustment:PGtkAdjustment):PGtkWidget
|
|
\end{lstlisting}
|
|
The \lstinline|Adjustment| parameters can be used to pass scrollbar widgets
|
|
that the scrolled window should use to do it's work.
|
|
If none are passed, the scrolled window will create the needed scrollbars
|
|
by itself.
|
|
|
|
The visibility of the scrollbars can be controlled with the policy property
|
|
of the scrolled window:
|
|
\begin{lstlisting}{}
|
|
gtk_scrolled_window_set_policy(scrolled_window:PGtkScrolledWindow;
|
|
hscrollbar_policy:TGtkPolicyType;
|
|
vscrollbar_policy:TGtkPolicyType)
|
|
\end{lstlisting}
|
|
The horizontal and vertical policies can be set to the following values:
|
|
\begin{description}
|
|
\item[GTK\_POLICY\_AUTOMATIC] Scrollbars are only visible if they are needed.
|
|
\item[GTK\_POLICY\_ALWAYS] Scrollbars are always visible.
|
|
\end{description}
|
|
|
|
After the creation of the scrolled window, the file list is created and
|
|
added to the scrolled window. A CList widget can be created using 2 calls;
|
|
\begin{lstlisting}{}
|
|
function gtk_clist_new (columns:gint):PGtkWidget;
|
|
function gtk_clist_new_with_titles (columns:gint;
|
|
titles:PPgchar):PGtkWidget;
|
|
\end{lstlisting}
|
|
In both cases, the number of columns in the list must be passed. If
|
|
the column header titles are fixed and known, they can be passed in the
|
|
\lstinline|gtk_clist_new_with_titles| call, but they can still be set and
|
|
retrieved later on with the following calls:
|
|
\begin{lstlisting}{}
|
|
Procedure gtk_clist_set_column_title(clist:PGtkCList;
|
|
column:gint;
|
|
title:Pgchar);cdecl;
|
|
function gtk_clist_get_column_title(clist:PGtkCList;
|
|
column:gint):Pgchar;cdecl;
|
|
\end{lstlisting}
|
|
Note that the column indices are 0 based.
|
|
|
|
After the CList widget has been created, some properties can be set:
|
|
\begin{lstlisting}{}
|
|
gtk_clist_set_shadow_type(Result,GTK_SHADOW_ETCHED_OUT);
|
|
\end{lstlisting}
|
|
This call sets the border around the clist. The possible values for
|
|
the last parameter (the \lstinline|TGtkShadowType|) of
|
|
\lstinline|gtk_clist_set_shadow_type| are:
|
|
\begin{description}
|
|
\item[GTK\_SHADOW\_NONE] No border.
|
|
\item[GTK\_SHADOW\_IN] the clist appears lowered.
|
|
\item[GTK\_SHADOW\_OUT] the clist appears raised.
|
|
\item[GTK\_SHADOW\_ETCHED\_IN] the clist appears with a lowered frame.
|
|
\item[GTK\_SHADOW\_ETCHED\_OUT] the clist appears with a raised frame.
|
|
\end{description}
|
|
|
|
The justification of a column in the list can be set:
|
|
\begin{lstlisting}{}
|
|
gtk_clist_set_column_justification(result,2,GTK_JUSTIFY_RIGHT);
|
|
\end{lstlisting}
|
|
column 2 will contain the file sizes, so it is set right-justified.
|
|
Other possible values are for justification are
|
|
\lstinline|GTK_JUSTIFY_LEFT|, \lstinline|GTK_JUSTIFY_CENTER|, and
|
|
\lstinline|GTK_JUSTIFY_FILL|, which have their obvious meanings.
|
|
|
|
To be able to select multiple items (or rows) at once, the selection mode of
|
|
the CList must be set:
|
|
\begin{lstlisting}{}
|
|
gtk_clist_set_selection_mode(Result,GTK_SELECTION_MULTIPLE);
|
|
\end{lstlisting}
|
|
Possible modes of selection are:
|
|
\begin{description}
|
|
\item[GTK\_SELECTION\_SINGLE] Only one row can be selected at any given
|
|
time.
|
|
\item[GTK\_SELECTION\_BROWSE] Multiple items can be selected, however the
|
|
selection will always return 1 item.
|
|
\item[GTK\_SELECTION\_MULTIPLE] Multiple items can be selected, and the
|
|
selection will contain all selected items.
|
|
\item[GTK\_SELECTION\_EXTENDED] The selection is always \lstinline|Nil|.
|
|
\end{description}
|
|
The selection is a field (\lstinline|selection|) of type \lstinline|PGList| in the
|
|
\lstinline|TGtkCList| record. A \lstinline|PGlist| is a pointer to a doubly linked
|
|
list with data pointers. More details about this will follow.
|
|
|
|
The elements in the list list can be sorted.
|
|
\begin{lstlisting}{}
|
|
gtk_clist_set_auto_sort(Result,True);
|
|
If DefCompare=Nil then
|
|
DefCompare:=Result^.compare;
|
|
gtk_clist_set_compare_func(Result,
|
|
TGtkCListCompareFunc(@FileCompareFunc));
|
|
\end{lstlisting}
|
|
By default, a CList sorts by comparing the texts in the current sort column
|
|
of the items in the list. This sorting happens using the \lstinline|compare|
|
|
function of the CList. The standard \lstinline|compare| function of the list
|
|
is saved here in a variable \lstinline|DefCompare|, so it can still be used.
|
|
Using the \lstinline|gtk_clist_set_compare_func| the compare function to be
|
|
used when sorting can be set, and it is set to the function
|
|
\lstinline|FileCompareFunc|, which will be discussed later on.
|
|
|
|
The \lstinline|gtk_clist_set_auto_sort| can be used to set the auto-sort
|
|
feature of the Clist. If auto-sort is on, adding new items to the CList will
|
|
insert them in the correct order. If auto-sort is off, new items are
|
|
appended to the beginning or end of the list.
|
|
|
|
After the sort function is set, handlers are attached to 2 signals:
|
|
\begin{lstlisting}{}
|
|
gtk_signal_connect(PgtkObject(Result),'button_press_event',
|
|
TGtkSignalFunc(@ShowPopup),MainWindow);
|
|
gtk_signal_connect(PgtkObject(Result),'click_column',
|
|
TGtkSignalFunc(@FileColumnClick),MainWindow);
|
|
\end{lstlisting}
|
|
The first handler connects to a mouse button press event. This will be used
|
|
to detect a right mouse click, and to show a popup menu:
|
|
\begin{lstlisting}{}
|
|
Procedure ShowPopup(Widget : PGtkWidget;
|
|
Event : PGdkEventButton;
|
|
Window : PMainWindow);cdecl;
|
|
|
|
begin
|
|
if (event^.thetype=GDK_BUTTON_PRESS) and
|
|
(event^.button=3) then
|
|
gtk_menu_popup(Window^.PMFiles,Nil,Nil,Nil,NIl,3,event^.time);
|
|
end;
|
|
\end{lstlisting}
|
|
The \lstinline|gtk_menu_popup| function does nothing but showing the menu;
|
|
when a menu item is clicked, the menu will close by itself.
|
|
|
|
The second handler connects to the 'click\_column' event. This event is
|
|
emitted if the user clicks on the column header. It will be used to switch
|
|
the sort order of the file list:
|
|
\begin{lstlisting}{}
|
|
Procedure FileColumnClick(List : PGtkCList;Column:gint; Window : PMainWindow);cdecl;
|
|
|
|
Var
|
|
I : longint;
|
|
NS : TGtkSortType;
|
|
|
|
begin
|
|
If Column<>List^.sort_column Then
|
|
begin
|
|
gtk_clist_set_sort_type(List,GTK_SORT_ASCENDING);
|
|
gtk_clist_set_sort_column(list,Column);
|
|
end
|
|
else
|
|
begin
|
|
If (List^.Sort_type=GTK_SORT_ASCENDING) Then
|
|
NS:=GTK_SORT_DESCENDING
|
|
else
|
|
NS:=GTK_SORT_ASCENDING;
|
|
gtk_clist_set_sort_type(List,NS);
|
|
end;
|
|
gtk_clist_sort(list);
|
|
end;
|
|
\end{lstlisting}
|
|
The function starts by retrieving the current sort column. If it is
|
|
different from the column the used clicked on, then 2 things are done:
|
|
\begin{enumerate}
|
|
\item The sort type is set to ascending.
|
|
\item The sort column is set to the column the user clicked.
|
|
\end{enumerate}
|
|
If, on the other hand, the user clicks on a column that is the sort column,
|
|
the sort type is simply reversed. After the sort column and sort type are
|
|
set, the list is epxlicitly sorted. (neither of the calls that set the sort
|
|
order or sort column forces a sort).
|
|
|
|
The sort happens using the \lstinline|compare| function (\lstinline|FileCompareFunc|)
|
|
that was set when the CList was created:
|
|
\begin{lstlisting}{}
|
|
Function FileCompareFunc(List:PGtkCList; Row1,Row2 : PGtkCListRow) : Longint; Cdecl;
|
|
|
|
Var
|
|
SC : Longint;
|
|
|
|
begin
|
|
SC:=List^.sort_column;
|
|
If SC in [2,3] then
|
|
begin
|
|
SC:=SC-2;
|
|
Result:=PLongint(Row1^.Data)[SC]-PLongint(Row2^.Data)[SC];
|
|
end
|
|
Else
|
|
Result:=DefCompare(List,Row1,Row2);
|
|
end;
|
|
\end{lstlisting}
|
|
This function receives 3 arguments:
|
|
\begin{itemize}
|
|
\item The list that needs to be sorted.
|
|
\item 2 pointers to the row objects that must be compared.
|
|
\end{itemize}
|
|
The result must be an integer that is negative if the first row should come
|
|
before the second or larger than zero if the second row should come before
|
|
the first. If the result is zero then the columns are considered the same.
|
|
|
|
The function checks what the sort column is. If it is not the size (2) or
|
|
date (3) column, then the default row compare function (which was saved in
|
|
the \lstinline|DefCompare| variable when the list was created) is used to
|
|
compare the rows. If the size or date columns must be compared, the user
|
|
data associated with the rows is examined. As will be shown below, the user
|
|
data will point to an array of 2 Longint values that describe the size and
|
|
datestamp of the file. The approriate values are compared and the result is
|
|
passed back.
|
|
|
|
To fill the file list with data, the \lstinline|FillList| function is
|
|
implemented:
|
|
\begin{lstlisting}{}
|
|
Function FillList(List : PGtkCList;
|
|
Const Dir,Mask : String) : Integer;
|
|
|
|
Var
|
|
Info : TSearchRec;
|
|
Size : Int64;
|
|
I,J : longint;
|
|
|
|
begin
|
|
Result:=0;
|
|
Size:=0;
|
|
gtk_clist_freeze(List);
|
|
Try
|
|
gtk_clist_clear(List);
|
|
If FindFirst (AddTrailingSeparator(Dir)+Mask,
|
|
faAnyFile,Info)=0 then
|
|
Repeat
|
|
Inc(Size,Info.Size);
|
|
AddFileToList(List,Info);
|
|
Inc(Result);
|
|
Until FindNext(Info)<>0;
|
|
FindClose(info);
|
|
finally
|
|
For I:=0 to 4 do
|
|
begin
|
|
J:=gtk_clist_optimal_column_width(List,i);
|
|
gtk_clist_set_column_width(List,i,J);
|
|
end;
|
|
gtk_clist_thaw(List)
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
This function is very straightforward. To start, it 'freezes' the list with
|
|
\lstinline|gtk_clist_freeze|; this prevents the list from updating the
|
|
screen each time a row is added or deleted. Omitting this call would cause
|
|
serious performance degradation and screen flicker.
|
|
|
|
After freezing the list, it is cleared; Then a simple loop is implemented
|
|
that scans the given directory with the given file mask using the
|
|
\lstinline|FindFirst|/\lstinline|FindNext| calls. For each file found
|
|
it calls the \lstinline|AddFileToList| function, that will actually add the
|
|
file to the list view, using the information found in the search record.
|
|
|
|
The \lstinline|AddTrailingSeparator| adds a directory separator to a
|
|
string containing the name of a directory if this does not end on a
|
|
separator yet. It can be found in the \file{futils} unit.
|
|
|
|
After the loop has finished, the optimal width for each column is
|
|
retrieved using the \lstinline|gtk_clist_optimal_column_width| function
|
|
and the result is used to set the column width. As a result, the columns will
|
|
have the correct size for displaying all items.
|
|
|
|
When this has been done, the list is 'thawed' with \lstinline|gtk_clist_thaw|,
|
|
which means that it will repaint itself if needed. This happens in a
|
|
\lstinline|finally| block since the \lstinline|gtk_clist_freeze| and
|
|
\lstinline|gtk_clist_thaw| work with a reference counter. For each 'freeze'
|
|
call the counter is increased. It is decreased with a 'thaw' call. When the
|
|
counter reaches zero, the list is updated.
|
|
|
|
The function that actually adds a row to the list view is quite simple:
|
|
\begin{lstlisting}{}
|
|
Procedure AddFileToList(List : PGtkCList; Info : TSearchRec);
|
|
|
|
Var
|
|
Texts : Array[1..6] of AnsiString;
|
|
FSD : PLongint;
|
|
I : longint;
|
|
|
|
begin
|
|
Texts[1]:=ExtractFileName(Info.Name);
|
|
Texts[2]:=ExtractFileExt(Info.Name);
|
|
Texts[3]:=FileSizeToString(Info.Size);
|
|
Texts[4]:=DateTimeToStr(FileDateToDateTime(Info.Time));
|
|
Texts[5]:=FileAttrsToString(Info.Attr);
|
|
Texts[6]:='';
|
|
i:=gtk_clist_append(List,@Texts[1]);
|
|
FSD:=GetMem(2*SizeOf(Longint));
|
|
FSD[0]:=Info.Size;
|
|
FSD[1]:=Info.Time;
|
|
gtk_clist_set_row_data_full (List,I,FSD,@DestroySortData);
|
|
end;
|
|
\end{lstlisting}
|
|
The \lstinline|gtk_clist_append| call accepts 2 paramers: a CList, and a
|
|
pointer to an array of zero-terminated strings. The array must contain as
|
|
much items as the CList has columns (in the above, the last column is
|
|
always empty, as this gives a better visual effect). The call adds a column
|
|
at the end of a list; An item can be inserted at the beginning of the list
|
|
with \lstinline|gtk_clist_append|, which accepts the same parameters. An
|
|
item can be inserted at certain position:
|
|
\begin{lstlisting}{}
|
|
gtk_clist_insert(clist:PGtkCList; row:gint; thetext:PPgchar);cdecl;
|
|
\end{lstlisting}
|
|
Note that all these calls do the same thing if the 'auto sort' was set for
|
|
the CList.
|
|
|
|
The \lstinline|FileAttrsToString| function converts file attributes to a
|
|
string of characters that indicate whether a given attribute is present.
|
|
It can be found in the \file{futils} unit and will not be shown here.
|
|
|
|
After the file data was appended to the CList, an array of 2 longints is
|
|
allocated on the heap. The first longint is filled with the size of the
|
|
file, the second with the date of the file. The pointer to this array is
|
|
then associated with the row that was just inserted with the
|
|
\lstinline|gtk_clist_set_row_data_full| call. There are 2 calls to
|
|
associate data with a row:
|
|
\begin{lstlisting}{}
|
|
gtk_clist_set_row_data(clist:PGtkCList;
|
|
row:gint;
|
|
data:gpointer);cdecl;
|
|
gtk_clist_set_row_data_full(clist:PGtkCList;
|
|
row:gint; data:gpointer;
|
|
destroy: :TGtkDestroyNotify);
|
|
\end{lstlisting}
|
|
the first call is used to add data to a clist that will not need to be
|
|
destroyed if the row is deleted. The second call can be used to pass a
|
|
callback that will be called when the row is destroyed.
|
|
|
|
In the case of the file list, the \lstinline|DestroySortData| call is
|
|
used to dispose the array with sort data:
|
|
\begin{lstlisting}{}
|
|
Procedure DestroySortData(FSD : Pointer);cdecl;
|
|
|
|
begin
|
|
FreeMem(FSD);
|
|
end;
|
|
\end{lstlisting}
|
|
The reason that the file list is cleared when the main window is destroyed
|
|
now becomes apparent: when the list is cleared, all data associated with
|
|
the file list is freed. If the call to \lstinline|gtk_clist_clear| is
|
|
omitted before destroying the main window, the list is not cleared and all
|
|
data stays in memory even after the window closes.
|
|
|
|
The display of the column titles of the file list can be switched on or off.
|
|
To do this a check menu item ('Hide titles') is added to the 'View' menu.
|
|
If the menu is clicked, the following callback is executed:
|
|
\begin{lstlisting}{}
|
|
Procedure ToggleFileListTitles(Sender : PGtkCheckMenuItem;
|
|
Window : PMainWindow);cdecl;
|
|
|
|
begin
|
|
If active(Sender^)=0 then
|
|
gtk_clist_column_titles_show(Window^.FileList)
|
|
else
|
|
gtk_clist_column_titles_hide(Window^.FileList)
|
|
end;
|
|
\end{lstlisting}
|
|
The \lstinline|active| function checks whether a check menu item is currently
|
|
checked ot not and shows or hides the titles.
|
|
|
|
Not only can the column titles be switched on or off, it is also possible to
|
|
control whether or not a given column must be shown;
|
|
|
|
Under the 'View' menu, there is a 'Hide columns' submenu that contains 4
|
|
check menus that can be used to toggle the visibility of the columns in the
|
|
file list. All the check menu items are connected to the following callback:
|
|
\begin{lstlisting}{}
|
|
Procedure ToggleFileListColumns(Sender : PGtkCheckMenuItem;
|
|
Window : PMainWindow);cdecl;
|
|
|
|
Var Col : Longint;
|
|
|
|
begin
|
|
With Window^ do
|
|
If Sender=MIShowExt Then
|
|
Col:=1
|
|
else if Sender=MiShowSize Then
|
|
Col:=2
|
|
else if Sender=MIShowDate then
|
|
Col:=3
|
|
else
|
|
Col:=4;
|
|
gtk_clist_set_column_visibility(Window^.FileList,
|
|
Col,
|
|
(Active(Sender^)=0));
|
|
end;
|
|
\end{lstlisting}
|
|
The call gets as 'user data' a pointer to the main window record. Using this
|
|
it checks which menu emitted the call, and updates the corresponding column
|
|
with the \lstinline|gtk_clist_set_column_visibility| function.
|
|
|
|
More attributes of a CList can be set, but they will not be discussed here;
|
|
the GTK documentation and tutorial offer an overview of the possibilities.
|
|
|
|
The selection mode of the CList has been set to allow selection of multiple
|
|
rows. The Clist maintains a linked list (A Glist) with the rows that are
|
|
part of the selection. The linked list contains the indexes of the selected
|
|
rows in it's associated data.
|
|
|
|
The linked list \lstinline|Glist| is often used in GTK applications.
|
|
It consists of the following records:
|
|
\begin{lstlisting}{}
|
|
TGList = record
|
|
data gpointer;
|
|
next,prev : PGlist;
|
|
end;
|
|
PGlist=^TGlist;
|
|
\end{lstlisting}
|
|
The selection of a CList is of type \lstinline|PGlist|. The \lstinline|data|
|
|
pointer can be typecasted to an integer to return the index of a selected
|
|
row.
|
|
|
|
The following function walks the selection linked list and stores the
|
|
associated filenames in a \lstinline|TStrings| class:
|
|
\begin{lstlisting}{}
|
|
Procedure GetFileSelection (List : PGtkClist; Selection : TStrings);
|
|
|
|
Var
|
|
SList : PGList;
|
|
Index : Longint;
|
|
P : PChar;
|
|
|
|
begin
|
|
Selection.Clear;
|
|
Slist:=List^.Selection;
|
|
While SList<>nil do
|
|
begin
|
|
Index:=Longint(SList^.Data);
|
|
gtk_clist_get_text(List,Index,0,@p);
|
|
Selection.Add(StrPas(p));
|
|
SList:=g_list_next(SList);
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
The \lstinline|gtk_clist_get_text| retrieves the text of a given cell in the
|
|
CList (a similar function exists to set the text) , and the
|
|
\lstinline|g_list_next| jumps to the next element in the linked list.
|
|
|
|
The \lstinline|TStrings| class is the standard string container as defined
|
|
in the \lstinline|Classes| unit of Free Pascal (or Delphi).
|
|
|
|
The above function will be used to retrieve the list of selected files so
|
|
operations can be done on the selection.
|
|
|
|
To retrieve the first (and possibly only) item of a selection, and the
|
|
number of items in a selection, the following functions can be used:
|
|
\begin{lstlisting}{}
|
|
Function GetFileFirstSelection (List : PGtkClist) : String;
|
|
|
|
Var
|
|
SList : PGList;
|
|
Index : Longint;
|
|
P : PChar;
|
|
|
|
begin
|
|
Result:='';
|
|
Slist:=List^.Selection;
|
|
If SList<>nil then
|
|
begin
|
|
Index:=Longint(SList^.Data);
|
|
gtk_clist_get_text(List,Index,0,@p);
|
|
Result:=StrPas(p);
|
|
end;
|
|
end;
|
|
|
|
Function GetFileSelectionCount (List : PGtkClist) : Longint;
|
|
|
|
Var
|
|
SList : PGList;
|
|
|
|
begin
|
|
Slist:=List^.Selection;
|
|
Result:=0;
|
|
While SList<>nil do
|
|
begin
|
|
Inc(Result);
|
|
SList:=g_list_next(SList);
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
These functions will be used further on.
|
|
|
|
The filelist is now ready to be used. To be able to select a directory from
|
|
which the files should be displayed, a Tree widget is used. How to create
|
|
this tree and connect it to the file list is explained in the next section.
|
|
|
|
\section{The directory tree}
|
|
The directory tree will allow the user to browse through the directories on
|
|
his system. When a directory is selected, the file view should be updated
|
|
to show the files in the selected directory.
|
|
|
|
To make the directory tree more efficient and less memory consuming, the
|
|
tree is not filled with the whole directory tree at once. Instead, only 2
|
|
levels of directories will be put in the tree. The tree is progessively
|
|
filled as the user expands the directory nodes.
|
|
|
|
The directory tree is created in the following function:
|
|
\begin{lstlisting}{}
|
|
Function NewDirtree (MainWindow : PMainWindow) : PGtkTree;
|
|
|
|
begin
|
|
Result:=PGtkTree(gtk_tree_new());
|
|
With MainWindow^ do
|
|
begin
|
|
TreeScrollWindow:=PGtkScrolledWindow(gtk_scrolled_window_new(Nil,Nil));
|
|
gtk_widget_show(PGtkWidget(TreeScrollWindow));
|
|
gtk_scrolled_window_set_policy(TreeScrollWindow,
|
|
GTK_POLICY_AUTOMATIC,
|
|
GTK_POLICY_AUTOMATIC);
|
|
gtk_scrolled_window_add_with_viewport(TreeScrollWindow,PGtkWidget(Result));
|
|
RootNode:=PGtkTreeItem(gtk_tree_Item_new_with_label(Pchar(PathSeparator)));
|
|
gtk_tree_append(Result,PgtkWidget(RootNode));
|
|
scandirs(PathSeparator,Result, RootNode,True,MainWindow);
|
|
gtk_tree_item_expand(rootnode);
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
The function starts off by creating the tree widget which is the return
|
|
value of the function.
|
|
|
|
Similar to the Clist, the tree widget does not possess functionality
|
|
for displaying scroll bars, so a 'scrolled window' is created,
|
|
in which the tree widget is placed.
|
|
|
|
A tree can have one or more tree items connected to it. Each of these tree
|
|
items can in turn have a tree associated with it, which in turn can again
|
|
have tree items associated. This way the tree is recursively constructed.
|
|
|
|
The directory tree is filled with 1 tree item, which will represent the root
|
|
directory of the disk which is browsed with the file explorer; The
|
|
\lstinline|gtk_tree_item_new_with_label| call returns a new tree item,
|
|
which is then appended to the tree using the \lstinline|gtk_tree_append|
|
|
call.
|
|
|
|
After this is done, the directories below the root directory are scanned and
|
|
appended to the root node in the \lstinline|scandirs| function, explained
|
|
below. If the root node was filled, then it is expanded with
|
|
\lstinline|gtk_tree_item_expand| (it can be collapsed with
|
|
\lstinline|gtk_tree_item_collapse|)
|
|
|
|
The \lstinline|scandirs| function scans a given directory for subdirectories
|
|
and appends each directory to a subtree of a given node. The subtree is
|
|
created if needed:
|
|
\begin{lstlisting}{}
|
|
Procedure Scandirs(Path: String; Tree : PgtkTree;
|
|
Node: PGtkTreeItem ; SubSub : Boolean;
|
|
Window : PMainWindow);
|
|
|
|
Var
|
|
NewTree : PGtkTree;
|
|
NewNode : PGtkTreeItem;
|
|
Info : TSearchRec;
|
|
S,FP : AnsiString;
|
|
|
|
begin
|
|
NewTree:=Nil;
|
|
FP:=AddTrailingSeparator(Path);
|
|
If FindFirst(FP+'*.*',faAnyfile,Info)=0 then
|
|
Try
|
|
repeat
|
|
If ((Info.Attr and faDirectory)=faDirectory) then
|
|
begin
|
|
S:=Info.Name;
|
|
If (S<>'.') and (S<>'..') then
|
|
begin
|
|
If (Node<>Nil) then
|
|
begin
|
|
If (NewTree=Nil) and (node<>Nil) then
|
|
begin
|
|
NewTree:=PGtkTree(gtk_tree_new);
|
|
gtk_tree_item_set_subtree(Node,PGtkWidget(NewTree));
|
|
end
|
|
end
|
|
else
|
|
NewTree:=Tree;
|
|
NewNode:=PGtkTreeItem(gtk_tree_item_new_with_label(Pchar(S)));
|
|
gtk_tree_append(NewTree,PgtkWidget(NewNode));
|
|
gtk_signal_connect(PGtkObject(NewNode),'select',
|
|
TGtkSignalFunc(@DirSelect),Window);
|
|
gtk_signal_connect(PGtkObject(NewNode),'expand',
|
|
TGtkSignalFunc(@DirExpand),Window);
|
|
If SubSub then
|
|
ScanDirs(FP+S,Tree,NewNode,False,Window);
|
|
gtk_widget_show(PGtkWidget(NewNode));
|
|
end;
|
|
end;
|
|
until FindNext(Info)<>0;
|
|
Finally
|
|
FindClose(Info);
|
|
end;
|
|
gtk_widget_show(PGtkWidget(Node));
|
|
end;
|
|
\end{lstlisting}
|
|
The routine is a simple loop. If a subdirectory is found then a new
|
|
tree widget is created (\lstinline|newTree|) and appended to the
|
|
given node with the \lstinline|gtk_tree_item_set_subtree| call.
|
|
|
|
For each found subdirectory a new treeitem is created and appended to
|
|
the subtree. 2 signals handlers are connected to the created tree item,
|
|
one for 'select' signal which is emitted when the user selects a tree item,
|
|
and one for the 'expand' signal which is emitted when the user expands a
|
|
node. Each of these handlers gets as data a pointer to the main window
|
|
record.
|
|
|
|
The \lstinline|SubSub| parameter is used to control the recursive behaviour.
|
|
If it is set to \lstinline|True|, the \lstinline|Scandirs| function will
|
|
call itself recursively, but only once. As a result only 2 levels of
|
|
subdirectories are scanned.
|
|
|
|
Finally, the created nodes are shown.
|
|
|
|
When the user expands a node, the \lstinline|DirExpand| function is
|
|
called:
|
|
\begin{lstlisting}{}
|
|
Procedure DirExpand(Item : PGtkTreeItem; Window : PMainWindow);cdecl;
|
|
|
|
Var
|
|
Dir : String;
|
|
SubTree : PGtkTree;
|
|
SubNodes : PGList;
|
|
Node : PGtkTreeItem;
|
|
|
|
begin
|
|
SubTree:=PgtkTree(Item^.SubTree);
|
|
SubNodes:=gtk_container_children(PGtkContainer(SubTree));
|
|
While SubNodes<>Nil do
|
|
begin
|
|
Node:=PgtkTreeItem(SubNodes^.Data);
|
|
If (Node^.SubTree<>Nil) then
|
|
gtk_tree_item_remove_subtree(Node);
|
|
Scandirs(GetPathName(Node),Nil,Node,False,Window);
|
|
SubNodes:=g_list_remove_link(SubNodes,SubNodes);
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
The function starts by retrieving the subtree of the tree item that
|
|
triggered the callback. It then retrieves the list of subnodes (treeitems)
|
|
of the subtree which represent the subdirectories of the directory node
|
|
that is about to be expanded. The Tree object descends from the GTK
|
|
container object, and keeps its treeitems in the container's children
|
|
list. This list is a Glist. The \lstinline|gtk_container_children| returns
|
|
a copy of the list containing the children.
|
|
|
|
Then a simple loop is executed: for each of
|
|
the found nodes, the subtree is destroyed if it exists:
|
|
\lstinline|gtk_tree_item_remove_subtree| removes a subtree from a treeItem
|
|
and destroys it.
|
|
|
|
After the subtree is destroyed, at the subirectory is scanned for possible
|
|
subdirecties (remark that the \lstinline|SubSub| parameter is set to
|
|
\lstinline|false|) and the subtree is recreated if needed.
|
|
|
|
The directory corresponding to a given node is calculated in the
|
|
\lstinline|GetPathName| function, explained below.
|
|
|
|
The next cycle of the loop is started by removing and destroying the first
|
|
element of the GList with the \lstinline|g_list_remove_link| call:
|
|
the call returns the new start of the list with the element removed. By
|
|
passing the first element of the list as the element to be removed the
|
|
whole list is traversed.
|
|
|
|
When the user selects a tree item, the list view must be updated with
|
|
the files in that directory. This is done in the \lstinline|DirSelect|
|
|
handler for the 'select' signal:
|
|
\begin{lstlisting}{}
|
|
Procedure DirSelect(Item : PGtkTreeItem; Window : PMainWindow);cdecl;
|
|
|
|
begin
|
|
ShowDir(Window,GetPathName(Item));
|
|
end;
|
|
|
|
Procedure ShowDir (Window : PMainWindow; Dir : String);
|
|
|
|
begin
|
|
With Window^ do
|
|
begin
|
|
FDir:=Dir;
|
|
FillList(FileList,Dir,FMask);
|
|
gtk_label_set_text(FilesHeader,pchar(Format(SFilesInDir,[Dir])));
|
|
end;
|
|
end;
|
|
|
|
\end{lstlisting}
|
|
The \lstinline|Showdir| function will be called from other places as
|
|
well hence it is put separately; The \lstinline|DirSelect| function
|
|
does nothing but to call the ShowDir function after it has calculated the
|
|
path of the treeitem that triggered the 'select' signal:
|
|
\begin{lstlisting}{}
|
|
Function GetPathName(Item : PGtkTreeItem) : String;
|
|
|
|
Var P : PChar;
|
|
PTree : PGtkTree;
|
|
begin
|
|
gtk_label_get(PgtkLabel(PGtkBin(Item)^.Child),@P);
|
|
Result:=StrPas(P);
|
|
If (PGtkWidget(item)^.Parent<>Nil) then
|
|
begin
|
|
PTree:=PGtkTree(PgtkWidget(Item)^.Parent);
|
|
If (Ptree^.Level<>0) Then
|
|
Result:=AddTrailingSeparator(GetPathName(PgtkTreeItem(PTree^.Tree_Owner)))+Result
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
It is a simple recursive mechanism. The only issue with this
|
|
routine is that one should know that the parent of a tree item is a tree,
|
|
and that the owner of the tree (in it's \lstinline|Tree_Owner| field) is
|
|
in turn again a treeitem. The \lstinline|Level| field of a tree determines
|
|
at what level the tree is located (i.e. the number of nodes present above
|
|
the tree) and can be used to check when the algorithm should stop.
|
|
|
|
An alternate approach would have been to associate with each node some
|
|
user data, such as a string that is the full path name of the node.
|
|
|
|
With this, the tree is created and is linked to the file list, so the
|
|
user has the capability to select any directory and display it's contents;
|
|
The user can also customize the view of the file list.
|
|
|
|
However, no actions can be performed on the files. This is treated in the
|
|
next sections, where a toolbar and popup menu are used to allow the user to
|
|
do things with the shown files.
|
|
|
|
\section{Adding a popup menu}
|
|
To allow the user to do something with the displayed files, a popup menu is
|
|
addd to the file list. Adding a popup menu is not different from adding a
|
|
main menu to a form, just it will not be attached to a menu bar. The popup
|
|
menu will be hidden till the user right-clicks in the file list.
|
|
|
|
The popup menu is created in the following function:
|
|
\begin{lstlisting}{}
|
|
Function NewFilePopupMenu (MainWindow : PMainWindow) : PGtkMenu;
|
|
|
|
begin
|
|
result:=PGtkMenu(gtk_menu_new);
|
|
gtk_signal_connect(PGtkObject(result),'show',
|
|
TGtkSignalFunc(@PMFilesActivate),MainWindow);
|
|
With MainWindow^ do
|
|
begin
|
|
PMIFileProperties:=AddItemToMenu(Result,Accel,'_Properties','',
|
|
TgtkSignalFunc(@DoProperties),
|
|
MainWindow);
|
|
PMIFileDelete:=AddItemToMenu(Result,Accel,'_Delete','<ctrl>d',
|
|
TgtkSignalFunc(@DeleteFile),
|
|
MainWindow);
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
The \lstinline|AddItemToMenu| functions were developed in an earlier
|
|
articles, and have been collected in the 'menus' unit.
|
|
|
|
The 'show' handler attached to the menu is used to set the state
|
|
of some of the menu items when the menu pops up:
|
|
\begin{lstlisting}{}
|
|
Procedure PMFilesActivate(Widget : PGtkWidget; Window : PMainWindow); cdecl;
|
|
|
|
Var State : TGtkStateType;
|
|
|
|
begin
|
|
if GetFileSelectionCount(Window^.FileList)>1 then
|
|
State:=GTK_STATE_INSENSITIVE
|
|
else
|
|
State:=GTK_STATE_Normal;
|
|
gtk_widget_set_state(PgtkWidget(Window^.PMIFileProperties),State);
|
|
end;
|
|
\end{lstlisting}
|
|
When more than 1 file is selected in the file view, the properties menu item
|
|
is disabled.
|
|
|
|
The popup menu will appear if the user clicks the right button in the file
|
|
list; The necessary event handler for that (\lstinline|ShowPopup|) was
|
|
attached to the CList and discussed earlier on.
|
|
|
|
The delete menu item has the following 'click' handler:
|
|
\begin{lstlisting}{}
|
|
Procedure DeleteFile(Widget : PGtkWidget; Window : PMainWindow); cdecl;
|
|
|
|
Var i : longint;
|
|
S : TStringList;
|
|
|
|
begin
|
|
S:=TStringList.Create;
|
|
Try
|
|
GetFileSelection(Window^.FileList,S);
|
|
For I:=0 to S.Count-1 do
|
|
begin
|
|
For I:=0 to S.Count-1 do
|
|
SysUtils.DeleteFile(Window^.FDir+S[i]);
|
|
end;
|
|
Finally
|
|
If S.Count>0 then
|
|
RefreshFileView(Window);
|
|
S.Free;
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
The routine simply retrieves the selection list and deletes all files
|
|
present in it; After that the file view is refreshed.
|
|
|
|
The properties popup menu action will be treated later on.
|
|
|
|
\section{Adding a toolbar}
|
|
The toolbar in the file explorer application will contain 2 buttons with
|
|
a pixmap on them; the pixmap will be loaded from data compiled into the
|
|
binary. The actions performed by the toolbar buttons will be the same as
|
|
the actions in the popup menu: show a file's properties and delete the file.
|
|
|
|
The creation of the toolbar for the file explorer program is done in the
|
|
following function:
|
|
\begin{lstlisting}{}
|
|
Function NewToolbar (MainWindow : PMainWindow) : PGtkToolbar;
|
|
|
|
begin
|
|
Result:=pGtkToolBar(gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
|
|
GTK_TOOLBAR_ICONS));
|
|
gtk_toolbar_append_item(result,
|
|
Nil,
|
|
'File Properties',
|
|
nil,
|
|
CreateWidgetFromXPm(PgtkWidget(MainWindow^.Window),
|
|
@PropertiesXPM),
|
|
TgtkSignalFunc(@DoProperties),
|
|
MainWindow);
|
|
gtk_toolbar_append_item(result,
|
|
Nil,
|
|
'Delete File',
|
|
Nil,
|
|
CreateWidgetFromXPm(PgtkWidget(MainWindow^.Window),
|
|
@DeleteXPM),
|
|
TgtkSignalFunc(@DeleteFile),
|
|
MainWindow);
|
|
end;
|
|
\end{lstlisting}
|
|
The \lstinline|gtk_toolbar_new| function creates a new toolbar. The first
|
|
argument to this call specifies the orientation for the toolbar. Possible
|
|
values for the orientation are:
|
|
\begin{description}
|
|
\item[GTK\_ORIENTATION\_HORIZONTAL] The toolbar is filled horizontally;
|
|
\item[GTK\_ORIENTATION\_VERTICAL] The toolbar is filled vertically;
|
|
\end{description}
|
|
The second argument determines the style of the toolbar; it can have the
|
|
following values:
|
|
\begin{description}
|
|
\item[GTK\_TOOLBAR\_TEXT] Toolbuttons just show a text.
|
|
\item[GTK\_TOOLBAR\_ICONS] Toolbuttons just show a pixmap.
|
|
\item[GTK\_TOOLBAR\_BOTH] toolbuttons show both a pixmap and text.
|
|
\end{description}
|
|
The style determines what widgets will be placed on new toolbuttons that
|
|
are added with the \lstinline|gtk_toolbar_append_item| or
|
|
\lstinline|gtk_toolbar_prepend_item| calls. If buttons are added to the
|
|
toolbar manually, the style has no effect.
|
|
|
|
The \lstinline|gtk_toolbar_append_item| call adds a new toolbar button
|
|
to the end of a toolbar. The \lstinline|gtk_toolbar_prepend_item| item
|
|
inserts a new button at the beginning of the toolbar. Both accept the
|
|
following arguments:
|
|
\begin{enumerate}
|
|
\item a pointer to the toolbar to which the item should be added.
|
|
\item a zero-terminated string with the text to be shown on the button.
|
|
\item a zero-terminated string with the tooltip text (the hint) for the button.
|
|
\item a zero terminated private tooltip text for the button.
|
|
\item an icon wiget, usually a GtkPixmap.
|
|
\item A callback function of type \lstinline|TGtkSignalFunc| that will be
|
|
executed when the user clicks the button.
|
|
\item Callback data pointer which will be passed to the callback.
|
|
\end{enumerate}
|
|
A toolbutton can also be inserted at a certain position with the
|
|
\lstinline|gtk_toolbar_insert_item| call. It accepts an additional (last)
|
|
argument, the position at which to insert the toolbutton.
|
|
|
|
For the toolbar of the file explorer program, the buttons contain no text
|
|
(since the \lstinline|GTK_TOOLBAR_ICONS| style was chosen for the toolbar)
|
|
they do contain an icon, a pixmap widget.
|
|
|
|
The pixmap widget is created with the following function:
|
|
\begin{lstlisting}{}
|
|
function CreateWidgetFromXPM (Window : PGtkWidget;
|
|
Data : PPChar) : PGtkWidget;
|
|
|
|
Var
|
|
mask : PGdkBitmap;
|
|
pixmap : PGdkPixMap;
|
|
|
|
begin
|
|
pixmap:=gdk_pixmap_create_from_xpm_d(window^.window,@mask,nil,ppgchar(Data));
|
|
Result:=gtk_pixmap_new(Pixmap,Mask);
|
|
gtk_widget_show(Result);
|
|
end;
|
|
\end{lstlisting}
|
|
This function accepts 2 arguments: A GTK window, and a pointer to an array
|
|
or zero-terminated strings which describe the pixmap. With these it creates
|
|
a gdk pixmap object with the \lstinline|gdk_pixmap_create_from_xpm_d| call.
|
|
this function expects the following arguments:
|
|
\begin{enumerate}
|
|
\item A pointer to a GDK window object. In the above, the GDK window of the
|
|
main window widget is used. This explains why the \lstinline|gtk_widget_realize|
|
|
call was made when creating the main window: When the widget is realized, a
|
|
window is allocated to it. If the main window widget was not realized, then
|
|
it's gdk window would be nil.
|
|
\item The address of a \lstinline|PGdkBitmap| which will be used to store
|
|
the mask of the created pixmap. The mask determines the transparent items
|
|
in the bitmap, and can be used when creating a pixmap widget. This may be
|
|
nil.
|
|
\item A pointer to a color that should be considered the transparent
|
|
color. This may be nil, in which case a default color is used.
|
|
\item A pointer to a XPM pixmap structure.
|
|
\end{enumerate}
|
|
After the GDK pixmap and the mask were created, a pixmap widget is created
|
|
from the GDK bitmap, and the widget is shown.
|
|
|
|
The pixmap data is in XPM format. The XPM format is an array of
|
|
zero-terminated strings which are organized as follows:
|
|
\begin{enumerate}
|
|
\item A string describing the pixmap dimensions and the number of colors.
|
|
The string is of the form
|
|
\begin{verbatim}
|
|
'width height #colors chars/color',
|
|
\end{verbatim}
|
|
So the string
|
|
\begin{verbatim}
|
|
'16 16 4 1'
|
|
\end{verbatim}
|
|
means a 16x16 bitmap, using 4 colors, described by 1 character per color.
|
|
\item A series of strings that describe the color. the number of strings
|
|
should equal the count specified in the first string. The color descriptions
|
|
should have the following form:
|
|
\begin{verbatim}
|
|
'X c #YYYYYY'
|
|
\end{verbatim}
|
|
here 'X' must be replaced by N characters, where N is the number of
|
|
characters per color that was specified in the first string. The YYYYYY
|
|
is a RGB color value, in hex format. Each red,green or blue value must
|
|
contain 2 or 4 characters. The string '\#FF0000' would describe red, just as
|
|
'\#FFFF00000000' would describe red.
|
|
|
|
Instead of a rgb value, 'None' can be specified to indicate a transparent
|
|
color.
|
|
Some examples of valid colors would be:
|
|
\begin{verbatim}
|
|
'. c #000000', { Black }
|
|
'# c #000080', { Dark Blue }
|
|
'a c None', { Transparent }
|
|
'b c #f8fcf8', { greyish }
|
|
\end{verbatim}
|
|
\item A series of strings of characters, each string describes one line of
|
|
the pixmap and is composed of the color characters described in the color
|
|
section. Each line has the same length, namely the width of the image
|
|
multiplied with the number of characters per color. Obviously, there
|
|
should be as many strings as the height of the pixmap.
|
|
\end{enumerate}
|
|
The \file{fxbitmaps} unit contains 2 such bitmaps; comments have been added.
|
|
|
|
After the toolbar has been added, the main form is finished. The
|
|
form in action is shown in figure \ref{fig:mainwin}.
|
|
\begin{figure}[ht]
|
|
\caption{The main window in action.}\label{fig:mainwin}
|
|
\epsfig{file=gtk4ex/mainwin.png,width=\textwidth}
|
|
\end{figure}
|
|
|
|
The toolbar contains a button to show the properties dialog. This dialog
|
|
will show the various properties of a file, and is discussed in the next
|
|
section.
|
|
|
|
\section{Adding some dialogs}
|
|
Adding some dialogs to the file explorer program is not so difficult.
|
|
Three are created, an about dialog, a file properties dialog, and a dialog
|
|
that allows to enter a file mask which will then be applied to the file
|
|
view. All three dialogs will be based on the standard GTK dialog.
|
|
|
|
Adding a dialog that shows the properties of a file is quite easy.
|
|
The standard GTK dialog widget contains 3 widgets; a vertical box
|
|
(\lstinline|vbox|) which can be used to drop widgets in, a separator
|
|
and a horizontal box (\lstinline|action_area|), which can be used to
|
|
put buttons (such as an 'OK' button) in.
|
|
|
|
The file properties dialog consists mainly of a table packed with labels and
|
|
some checkboxes. It is created in the following function:
|
|
\begin{lstlisting}{}
|
|
Type
|
|
TFilePropertiesDialog = Record
|
|
Window : PgtkDialog;
|
|
Table : PGtkTable;
|
|
OkButton : PGtkButton;
|
|
Labels : Array[0..1,0..NrTableLines] of PGtkLabel;
|
|
CheckBoxes : Array[CheckBoxLineStart..NrTableLines] of PgtkCheckButton;
|
|
end;
|
|
PFilePropertiesDialog = ^TFilePropertiesDialog;
|
|
|
|
Function NewFilePropertiesDialog(FileName : String) : PFilePropertiesDialog;
|
|
Const
|
|
CheckAttrs : Array [CheckBoxLineStart..NrTableLines] of Integer
|
|
= (faReadOnly,faArchive,faHidden,faSysFile);
|
|
|
|
Var
|
|
Info : TSearchRec;
|
|
I : Longint;
|
|
|
|
begin
|
|
Result:=New(PFilePropertiesDialog);
|
|
With Result^ do
|
|
begin
|
|
Window:=PgtkDialog(gtk_dialog_new);
|
|
gtk_window_set_title(PgtkWindow(Window),SPropsTitle);
|
|
gtk_window_set_modal(PgtkWindow(Window),True);
|
|
gtk_window_set_policy(PgtkWindow(Window),0,0,0);
|
|
gtk_window_set_position(PGtkWindow(Window),GTK_WIN_POS_CENTER);
|
|
OkButton:=PGtkButton(gtk_button_new_with_label(SOK));
|
|
gtk_box_pack_start(PgtkBox(Window^.action_area),PGtkWidget(Okbutton),False,False,5);
|
|
gtk_window_set_focus(PGtkWindow(Window),PGtkWidget(OkButton));
|
|
gtk_widget_show(PGtkWidget(OkButton));
|
|
\end{lstlisting}
|
|
The above are standard things: The dialog window title is set, the dialog is
|
|
made modal, the resizing of the window is prohibited with the
|
|
\lstinline|gtk_window_set_policy| call. Then the window is told that it
|
|
should position itself in the center of the screen with the
|
|
\lstinline|gtk_window_set_position| call. The position specifier can be one
|
|
of the following:
|
|
\begin{description}
|
|
\item[GTK\_WIN\_POS\_NONE] The window manager will decide where the window
|
|
goes.
|
|
\item[GTK\_WIN\_POS\_CENTER] The window is placed at the center of the
|
|
screen.
|
|
\item[GTK\_WIN\_POS\_MOUSE] The window is placed where the mouse cursor is.
|
|
\end{description}
|
|
After the window properties have been set, an OK button is placed in the
|
|
action area, and it gets the focus.
|
|
|
|
Next, a table is created with \lstinline|NrTableLines+1| rows and 2 columns,
|
|
and put in the vbox area:
|
|
\begin{lstlisting}{}
|
|
Table:=PgtkTable(gtk_table_new(NrTableLines+1,2,TRUE));
|
|
gtk_box_pack_start(PGtkBox(Window^.vbox),PGtkWidget(Table),True,True,10);
|
|
\end{lstlisting}
|
|
Then the table is filled with labels that describe the various properties;
|
|
the left column contains labels that simplu
|
|
\begin{lstlisting}{}
|
|
For I:=0 to NrTableLines do
|
|
begin
|
|
Labels[0,i]:=PGtkLabel(gtk_label_new(LabelTexts[i]));
|
|
gtk_label_set_justify(Labels[0,I],GTK_JUSTIFY_RIGHT);
|
|
gtk_table_attach_defaults(Table,PgtkWidget(Labels[0,I]),0,1,I,I+1);
|
|
end;
|
|
For I:=0 to CheckboxLineStart-1 do
|
|
begin
|
|
Labels[1,i]:=PGtkLabel(gtk_label_new(''));
|
|
gtk_label_set_justify(Labels[1,I],GTK_JUSTIFY_LEFT);
|
|
gtk_table_attach_defaults(Table,PgtkWidget(Labels[1,I]),1,2,I,I+1);
|
|
end;
|
|
\end{lstlisting}
|
|
The file attributes will be represented with checkboxes:
|
|
\begin{lstlisting}{}
|
|
For I:=CheckboxLineStart to NrTableLines do
|
|
begin
|
|
checkBoxes[i]:=PgtkCheckButton(gtk_check_button_new_with_label(CheckBoxTexts[I]));
|
|
gtk_widget_set_state(PGtKWidget(CheckBoxes[i]),GTK_STATE_INSENSITIVE);
|
|
gtk_table_attach_defaults(Table,PgtkWidget(CheckBoxes[i]),1,2,I,I+1);
|
|
end;
|
|
\end{lstlisting}
|
|
The checkboxes are made inactive, so the user cannot change them.
|
|
|
|
After all labels and checkboxes are put in place, the file information
|
|
is put into various places:
|
|
\begin{lstlisting}{}
|
|
gtk_label_set_text(Labels[1,0],PChar(ExtractFileName(FileName)));
|
|
gtk_label_set_text(Labels[1,1],PChar(ExtractFilePath(FileName)));
|
|
gtk_label_set_text(Labels[1,2],PChar(ExtractFileExt(FileName)+SFile));
|
|
If FindFirst(FileName,faAnyFile,Info)=0 Then
|
|
begin
|
|
gtk_label_set_text(Labels[1,3],PChar(FileSizeToString(Info.Size)));
|
|
gtk_label_set_text(Labels[1,4],PChar(DateTimeToStr(FileDateToDateTime(Info.Time))));
|
|
For I:=CheckboxLineStart to NrTableLines do
|
|
If (CheckAttrs[i] and Info.Attr)=CheckAttrs[i] then
|
|
gtk_toggle_button_set_active(PgtkToggleButton(CheckBoxes[I]),True);
|
|
FindClose(Info);
|
|
end;
|
|
\end{lstlisting}
|
|
Finally, the 'destroy' callback for the window is set, and the OK button's
|
|
'click' signal is attached to the destroy method of the window widget:
|
|
\begin{lstlisting}{}
|
|
gtk_signal_connect(PGtkObject(Window),'destroy',
|
|
TGTKSignalFunc(@DestroyPropDialog),Result);
|
|
gtk_signal_connect_object(PgtkObject(OKButton),'clicked',
|
|
GTK_SIGNAL_FUNC(@gtk_widget_destroy),
|
|
PGTKOBJECT(Window));
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
Showing the properties dialog is simple:
|
|
\begin{lstlisting}{}
|
|
Procedure ShowFilePropertiesDialog(Dialog : PFilePropertiesDialog);
|
|
|
|
begin
|
|
gtk_widget_show_all(PgtkWidget(Dialog^.Window));
|
|
end;
|
|
\end{lstlisting}
|
|
|
|
The result of all this is shown in figure \ref{fig:fileprops}.
|
|
\begin{figure}[ht]
|
|
\begin{center}
|
|
\caption{The file properties dialog.}\label{fig:fileprops}
|
|
\epsfig{file=gtk4ex/fileprops.png,width=8cm}
|
|
\end{center}
|
|
\end{figure}
|
|
|
|
The handling of the mask form is a little bit more complicated than the
|
|
properties dialog, since the mask form should return some information
|
|
to the main form.
|
|
|
|
The creation of the mask form is again a standard matter, and the reader
|
|
is referred to the code on the CD-ROM to see how it is handled. The
|
|
only thing worth noting is the handling of the click on the 'OK' button that
|
|
appears on the form.
|
|
\begin{lstlisting}{}
|
|
gtk_signal_connect(PgtkObject(OKButton),'clicked',
|
|
TGtkSignalFunc(@ApplyMask),Result);
|
|
gtk_signal_connect_object(PgtkObject(OKButton),'clicked',
|
|
GTK_SIGNAL_FUNC(@gtk_widget_destroy),
|
|
PGTKOBJECT(Window));
|
|
\end{lstlisting}
|
|
Two handlers are added to the 'clicked' signal of the 'OK' button.
|
|
The first one is pointed to a function that will apply the mask, and the
|
|
second one is redirected to the destroy method of the dialog window wigdet.
|
|
\begin{lstlisting}{}
|
|
Procedure ApplyMask(Widget : PGtkWidget; Window : PMaskForm);cdecl;
|
|
|
|
begin
|
|
With Window^ do
|
|
begin
|
|
Mask:=StrPas(gtk_entry_get_text(EMask));
|
|
If (CallBack<>Nil) then
|
|
CallBack(Mask,CallBackData);
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
The \lstinline|TMaskForm| record that contains fields for all widgets on
|
|
the mask entry form also contains 2 fields that allow the OK button to notify
|
|
the calling program of the new mask:
|
|
\begin{lstlisting}{}
|
|
TMaskCallBack = Procedure (Mask : String; Data : Pointer);
|
|
TMaskForm = Record
|
|
{ ... widget fields ... }
|
|
Mask : ShortString;
|
|
CallBack : TMaskCallBack;
|
|
CallBackData : Pointer;
|
|
end;
|
|
PMaskForm = ^TMaskForm;
|
|
\end{lstlisting}
|
|
If the callback field is set, then the \lstinline|ApplyMask| function will call
|
|
it and pass it the new mask and some arbitrary pointer.
|
|
|
|
The main form contains a 'file mask' menu item, which has the following
|
|
'click' handler:
|
|
\begin{lstlisting}{}
|
|
procedure DoMask(Widget : PGtkWidget ; MainForm : PMainWindow ); cdecl;
|
|
|
|
Var
|
|
S : AnsiString;
|
|
|
|
begin
|
|
With NewMaskForm^ do
|
|
begin
|
|
S:=MainForm^.FMask;
|
|
gtk_entry_set_text(EMask,PChar(S));
|
|
CallBack:=@ApplyMask;
|
|
CallBackData:=MainForm;
|
|
gtk_widget_show_all(PgtkWidget(Window));
|
|
end;
|
|
end;
|
|
\end{lstlisting}
|
|
When the user clicks the 'file mask' menu item, A mask entry form is created.
|
|
The current file mask is filled in the entry widget (\lstinline|EMask|).
|
|
The callback is set, and the callbackdata is set to the pointer to the main
|
|
window record. The callback that is executed when the user clicks the OK
|
|
button on the mask form is the following:
|
|
\begin{lstlisting}{}
|
|
Procedure ApplyMask(Mask : String; Data : Pointer);
|
|
|
|
begin
|
|
PMainWindow(data)^.FMask:=Mask;
|
|
RefreshFileView(PMainWindow(Data));
|
|
end;
|
|
\end{lstlisting}
|
|
|
|
The reason that this system of callbacks is needed is that the
|
|
\lstinline|gtk_widget_show_all| immediatly returns when the mask entry form is
|
|
shown. Even though the mask entry form dialog is a modal dialog (i.e. it alone will
|
|
respond to mouse clicks and key presses) the call returns immediatly,
|
|
there is no counterpart for the Delphi \lstinline|ShowModal| function.
|
|
|
|
When the \lstinline|gtk_widget_show_all| returns, the mask entry form is still on
|
|
the screen, so the changes made in the mask form must be communicated
|
|
back to the main form by means of a callback which is executed when
|
|
the mask entry form is closed.
|
|
|
|
The mask form in action is shown in figure \ref{fig:filemask}.
|
|
\begin{figure}[ht]
|
|
\begin{center}
|
|
\caption{The file properties dialog.}\label{fig:filemask}
|
|
\epsfig{file=gtk4ex/filemask.png,width=8cm}
|
|
\end{center}
|
|
\end{figure}
|
|
|
|
\section{Finishing the application}
|
|
In several places in this article, a reference was made to the main menu.
|
|
The main menu is created in the \lstinline|NewMainMenu| function; since
|
|
menus were discussed extensively in the previous article on programming GTK,
|
|
the code will not be presented here. The various calls developed in the
|
|
previous article have been collected in the \file{menus} unit. One
|
|
additional call was added which adds a check menuitem to a menu; the call is
|
|
similar to the regular menu item calls, and will not be discussed here.
|
|
|
|
The application is built in such a way that it can easily be extended.
|
|
Only 2 file actions have been implemented, but many more can be made.
|
|
Missing functionality includes:
|
|
\begin{itemize}
|
|
\item Renaming of files. The CList allows to put an arbitrary widget into
|
|
a cell; this functionality could be used to allow the user to change the
|
|
filename by simply editing it.
|
|
\item Moving and copying of files, using drag and drop.
|
|
\item Duplicating the main window, or spawning a new window.
|
|
\item Opening a file in another application.
|
|
\item Improve the look of the file properties form.
|
|
\item On Windows, support for showing different drives should be added.
|
|
\end{itemize}
|
|
And without doubt, many more can be found.
|
|
|
|
\end{document} |