< Development‎ | Tutorials
Revision as of 15:50, 14 July 2012 by AnneW (talk | contribs)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

Development/Tutorials/Saving and loading (ko)

The printable version is no longer supported and may have rendering errors. Please update your browser bookmarks and please use the default browser print function instead.

파일 로드하고 저장하기
Tutorial Series   Beginner Tutorial
Previous   Tutorial 3 - KActions
What's Next   Tutorial 5 - KCmdLineArgs 사용하기
Further Reading   KIO::NetAccess QFile


이제 기본적인 텍스트 에디터 인터페이스를 가지게 되었다. 이제는 이것을 좀 더 유용하게 만들 시간이다. 가장 기본적으로 텍스트 에디터는 디스트에서 파일을 로드하고, 당식이 생성했거나 수정한 파일에 저장하거나 파일을 새롭게 생성하도록 할 필요가 있다.

Now that we have a basic text editor interface, it's time to make it do something useful. At the most basic, a text editor needs to be able to load files from disc, save files that you've created/edited and create new files.

KDE는 개발자가 좀 더 나은 삶을 위하여 파일을 다루기 위한 많은 클래스를 제공한다. KIO 라이브러리는 표준 다이얼로그와 같은 투명한 네트워크를 통해 파일을 쉽게 접근할 수 있도록 해준다.

KDE provides a number of classes for working with files which make life a lot easier for developers. The KIO library allows you to easily access files through network-transparent protocols as well as providing standard file dialogs.



 1 #include <KApplication>
 2 #include <KAboutData>
 3 #include <KCmdLineArgs>
 5 #include "mainwindow.h"
 7 int main (int argc, char *argv[])
 8 {
 9   KAboutData aboutData( "tutorial4", "tutorial4",
10       ki18n("Tutorial 4"), "1.0",
11       ki18n("A simple text area which can load and save."),
12       KAboutData::License_GPL,
13       ki18n("Copyright (c) 2007 Developer") );
14   KCmdLineArgs::init( argc, argv, &aboutData );
15   KApplication app;
17   MainWindow* window = new MainWindow();
18   window->show();
19   return app.exec();
20 }

main.cpp는 tutrial 3를 tutrial4로 변경한 것을 제외하고는 튜트리얼3에서 변경된 점이 없다.

main.cpp hasn't changed from tutorial 3 except to change any reference to tutorial 3 to tutorial 4.


 1 #ifndef MAINWINDOW_H
 2 #define MAINWINDOW_H
 4 #include <KXmlGuiWindow>
 5 #include <KTextEdit>
 7 class MainWindow : public KXmlGuiWindow
 8 {
 9   Q_OBJECT //new from tutorial3
11   public:
12     MainWindow(QWidget *parent=0);
14   private:
15     KTextEdit* textArea;
16     void setupActions();
17     QString fileName; //new
19   private slots: //new
20     void newFile(); //new
21     void openFile(); //new
22     void saveFile(); //new
23     void saveFileAs(); //new
24     void saveFileAs(const QString &outputFileName); //new
25 };
27 #endif

파일을 로드하고, 저장하는 기능을 추가하려면, 그러한 일을 하는 함수를 만들어야 한다. Qt의 시그널/슬롯 메커니즘을 통해 함수가 호출되기 위해, 19번째 줄에서 수행할 슬롯으로 이러한 함수들을 선언해야 한다. 이 헤더 파일에 있는 슬롯을 사용하는 중이라면, Q_OBJECT 매크로를 추가해야 한다.

Since we want to add the ability to load and save files, we must add the functions which will do the work. Since the functions will be called through Qt's signal/slot mechanism we must specify that these functions are slots as we do on line 19. Since we are using slots in this header file, we must also add the Q_OBJECT macro.

또한 우리는 현재 열린 파일의 파일 이름의 흔적을 유지하기를 원하므로, QString fileName을 선언하였다.

We also want to keep track of the filename of the currently opened file so we declare a QString fileName.


  1 #include "mainwindow.h"
  3 #include <KApplication>
  4 #include <KAction>
  5 #include <KLocale>
  6 #include <KActionCollection>
  7 #include <KStandardAction>
  8 #include <KFileDialog> //new
  9 #include <KMessageBox> //new
 10 #include <KIO/NetAccess> //new
 11 #include <KSaveFile> //new
 12 #include <QTextStream> //new
 14 MainWindow::MainWindow(QWidget *parent)
 15     : KXmlGuiWindow(parent),
 16       fileName(QString()) //new
 17 {
 18   textArea = new KTextEdit;
 19   setCentralWidget(textArea);
 21   setupActions();
 22 }
 24 void MainWindow::setupActions()
 25 {
 26   KAction* clearAction = new KAction(this);
 27   clearAction->setText(i18n("Clear"));
 28   clearAction->setIcon(KIcon("document-new"));
 29   clearAction->setShortcut(Qt::CTRL + Qt::Key_W);
 30   actionCollection()->addAction("clear", clearAction);
 31   connect(clearAction, SIGNAL(triggered(bool)),
 32           textArea, SLOT(clear()));
 34   KStandardAction::quit(kapp, SLOT(quit()),
 35                         actionCollection());
 37   KStandardAction::open(this, SLOT(openFile()),
 38                         actionCollection()); //new
 40   KStandardAction::save(this, SLOT(saveFile()),
 41                         actionCollection()); //new
 43   KStandardAction::saveAs(this, SLOT(saveFileAs()),
 44                         actionCollection()); //new
 46   KStandardAction::openNew(this, SLOT(newFile()),
 47                         actionCollection()); //new
 49   setupGUI();
 50 }
 52 //New from here on
 54 void MainWindow::newFile()
 55 {
 56   fileName.clear();
 57   textArea->clear();
 58 }
 60 void MainWindow::saveFileAs(const QString &outputFileName)
 61 {
 62   KSaveFile file(outputFileName);
 63   file.open();
 65   QByteArray outputByteArray;
 66   outputByteArray.append(textArea->toPlainText());
 67   file.write(outputByteArray);
 68   file.finalize();
 69   file.close();
 71   fileName = outputFileName;
 72 }
 74 void MainWindow::saveFileAs()
 75 {
 76   saveFileAs(KFileDialog::getSaveFileName());
 77 }
 79 void MainWindow::saveFile()
 80 {
 81   if(!fileName.isEmpty())
 82   {
 83     saveFileAs(fileName);
 84   }
 85   else
 86   {
 87     saveFileAs();
 88   }
 89 }
 91 void MainWindow::openFile()
 92 {
 93   QString fileNameFromDialog = KFileDialog::getOpenFileName();
 95   QString tmpFile;
 96   if(KIO::NetAccess::download(fileNameFromDialog, tmpFile, 
 97          this))
 98   {
 99     QFile file(tmpFile);
100     file.open(QIODevice::ReadOnly);
101     textArea->setPlainText(QTextStream(&file).readAll());
102     fileName = fileNameFromDialog;
104     KIO::NetAccess::removeTempFile(tmpFile);
105   }
106   else
107   {
108     KMessageBox::error(this, 
109         KIO::NetAccess::lastErrorString());
110   }
111 }


 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <gui name="tutorial4"
 3      version="1"
 4      xmlns="http://www.kde.org/standards/kxmlgui/1.0"
 5      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 6      xsi:schemaLocation="http://www.kde.org/standards/kxmlgui/1.0
 7                          http://www.kde.org/standards/kxmlgui/1.0/kxmlgui.xsd" >
 9   <MenuBar>
10     <Menu name="file" >
11       <Action name="clear" />
12     </Menu>
13   </MenuBar>
15   <ToolBar name="mainToolBar" >
16     <text>Main Toolbar</text>
17     <Action name="clear" />
18   </ToolBar>
20 </gui>

name이 'tutorial4'로 바뀐 것을 제외하고 tutrial 3의 tutorial3ui.rc과 동일하다. 우리는 KStandardAction에 대한 어떤 정보도 넣을 필요가 없다. 이 액션의 배치들은 KDE에 의해서 자동적으로 다루어지기 때문이다.

This is identical to tutorial3ui.rc from tutorial 3 except the name has changed to 'tutorial4'. We do not need to add any information about any of the KStandardActions since the placement of those actions is handled automatically by KDE.


자, 이제 로드하거나 저장하기를 수행할 코드를 구현한다. 이것은 mainwindow.cpp에서 모든 것이 일어날 것이다.

Okay, now to implement the code that will do the loading and saving. This will all be happening in mainwindow.cpp

우리가 할 첫번째 일은

The first thing we do is add

위의 코드를 16번째 줄인 MainWindow 생성자 리스트에 추가하는 것이다. 이것은 시작할 때 fileName이 비어 있도록 해준다.

to the MainWindow constructor list on line 16. This makes sure that fileName is empty right from the beginning.

액션 추가하기

우리가 해야할 첫번째 일은 유저가 어플리케이션에서 로드하고 저장할수 있도록 하기 위한 외부 인터패이스를 제공하는 것이다. 튜트리얼 3에서 quit와 같이 우리는 KStandardActions을 사용할 것이다. 37번째 줄에서 47번째 줄에서, quit 액션과 같은 방식으로 액션을 추가하였다. 각각을 위해 이 액션들을 헤더파일에서 우리가 선언했던 적당한 슬롯에 연결한다.

The first thing we are going to do is provide the outward interface for the user so they can tell the application to load and save. Like with the quit action in tutorial 3, we will use KStandardActions. On lines 37 to 47 we add the actions in the same way as for the quit action. For each one, we connect it to the appropriate slot that we declared in the header file.

새 문서 생성하기

The first function we create is the newFile() function.

우리가 만든 첫번째 함수는 newFile() 함수이다.
void MainWindow::newFile()

fileName.clear()는 디스크에 이 문서가 아직 존재하재하지 않는다는 사실을 반영하기 위해 fileName QString을 비우도록 설정한다. textArea->clear()은 튜트리얼 3에서 우리가 clear KAction에 연결한 함수와 같은 함수를 사용하여 중앙의 텍스트 공간을 클리어한다.

fileName.clear() sets the fileName QString to be empty to reflect the fact that this document does not yet have a presence on disc. textArea->clear() then clears the central text area using the same function that we connected the clear KAction to in tutorial 3.

파일 저장하기


이제 첫번째 파일을 다루는 코드를 살펴보자. 우리는 파라미터로 주어진 파일이름으로 텍스트 공간의 내용을 저장할 함수를 구현할 것이다. KDE는 Qt의 QFile에서 상속되고, 파일을 안전하기 위해 저장하기 위한 KSaveFile라는 클래스를 제공한다.

Now we get onto our first file handling code. We're going to implement a function which will save the contents of the text area to the file name given as a parameter. KDE provides a class for safely saving a file called KSaveFile which is derived from Qt's QFile.

이 함수 원형은 아래와 같다.

The function's prototype is
void MainWindow::saveFileAs(const QString &outputFileName)
우리는 KSaveFile오브젝트를 생성하고 그것을 연다.
We then create our KSaveFile object and open it with
KSaveFile file(outputFileName);

이제 우리는 작성한 파일을 가지고 있으며, 파일을 쓰여질 수 있는 형식으로 text area의 텍스트롤 포맷을 지정해야할 필요가 있다. 이것을 위해, 우리는 QByteArray을 생성하며, text area안의 어떠한 텍스트 버전이든지 채운다.:

Now that we have our file to write to, we need to format the text in the text area to a format which can be written to file. For this, we create a QByteArray and fill it with the plain text version of whatever is in the text area:
QByteArray outputByteArray;

이제 QByteArray롤 가지고 있으며, KSaveFile::write()로 파일을 작성기 위해 이것을 사용한다. 만약 일반적인 QFile을 사용하였다면, 이것은 즉시 변경될 것이다. 그러나 만약 작성도중 부분적으로 문제가 발생한다면, 파일은 오류를 일으키게 된다. 이러한 이유로 KSaveFile은 임시적인 파일을 첫번째로 작성하여 동작하고, KSaveFile::finalize()을 호출할 때, 변화된 것이 실제적으로 저장된다.

Now that we have our QByteArray, we use it to write to the file with KSaveFile::write(). If we were using a normal QFile, this would make the changes immediately. However, if a problem occurred partway through writing, the file would become corrupted. For this reason, KSaveFile works by first writing to a temporary file and then, when you call KSaveFile::finalize() the changes are made to the actual file.

마지막으로 우리는 MainWindowsfileName 멤버를 우리가 저장한 파일이름을 지정하도록 설정한다.

Finally, we set MainWindows's fileName member to point to the file name we just saved to.
fileName = outputFileName;


이 함수가 saveAs 슬롯이 연결된 함수이다.이것은 일반적으로 간단히 saveFileAs(QString) 함수라고 부르며, KFileDialog::getSaveFileName()에 의해 리턴되는 파일 이름을 얻는다.

This is the function that the saveAs slot is connected to. It simply calls the generic saveFileAs(QString) function and passes the file name returned by KFileDialog::getSaveFileName().
void MainWindow::saveFileAs()

이것은 KIO 라이브러리의 첫번째 실질적인 사용이다. KFileDialog은 모든 KDE 어플리케이션에서 사용되는 공통 파일 다이얼로그를 보여주기 위한 많은 static 함수를 제공한다. KFileDialog::getSaveFileName()를 호출하는 것은 유저가 저장할 파일의 이름은 선택하거나, 새로운 이름을 고르를 수 있는 다이얼로그를 디스플레이할 것이다. 이 함수는 saveFileAs(QString)에 넘기는 전체 파일 이름을 리턴한다.

This our first actual use of the KIO library. KFileDialog provides a number of static functions for displaying the common file dialog that is used by all KDE applications. Calling KFileDialog::getSaveFileName() will display a dialog where the user can select the name of the file to save to or choose a new name. The function returns the full file name, which we then pass to saveFileAs(QString).


void MainWindow::saveFile()

이 함수 안에 흥미롭거나 새로운 것은 없다. 단지 다이얼로그를 보일지 말지를 결정하는 로직일 뿐이다. 만약 fileName가 비어 있지 않다면, 파일은 fileName으로 저장된다. 그러나 만약 비어있다면, 유저가 파일 이름을 선택하기 위한 다이얼로그를 보여준다.

There's nothing exciting or new in this function, just the logic to decide whether or not to show the save dialog. If fileName is not empty, then the file is saved to fileName. But if it is, then the dialog is shown to allow the user to select a file name.

파일 로드하기

마지막으로 디스크에서부터 파일을 로드할 수 있는 차례가 되었다. 이것을 위한 코드는 모든 것을 포함한 MainWindow::openFile()이다.

Finally, we get round to being able to load a file from disc. The code for this is all contained in MainWindow::openFile().

먼저 우리는 그들이 열기를 원하는 파일의 이름을 유저에게 물어보아야한다. 우리는 이것을 KFileDialog의 또 다른 종류인 getOpenFileName()을 사용하여 수행할 것이다.:

First we must ask the user for the name of the file they wish to open. We do this using another one of the KFileDialog functions, this time getOpenFileName():
QString fileNameFromDialog = KFileDialog::getOpenFileName();

이제 우리는 우리의 파일을 검색하기 위해 KIO 라이브러리를 사용한다. 이것은 FTP 사이트와 같이 원격 위치에 저장되어 있더라도, QFile로 파일을 열도록 해줄 것이다. 우리는 NetAccessdownload() 함수에 대한 호출을 생성한다.

Then we use the KIO library to retrieve our file. This allows us to open the file with QFile even if it's stored in a remote location like an FTP site. We make the following call to NetAccess's download() function
KIO::NetAccess::download(fileNameFromDialog, tmpFile, this)

이 함수의 첫번째 인자는 당신이 다운로드 받기를 원하는 파일의 이름이다. 두번째 인자는 다운로드가 완료되었을 때, 파일의 임시적인 복사본의 위치를 포함하는 QString이다. 이것이 이제부터 우리가 작업할 tmpFile이다.

The first argument is the name of the file you wish to download. The second is a QString which, after the download is complete, will contain the location of the temporary copy of the file. It is this tmpFile we will work with from now on.

이 함수는 전송이 성공적이었는지에 의존하여 truefalse를 리턴한다. 만약 이것이 실패하였다면, 우리는 주어진 에러 메세지 박스를 디스플레이한다.:

The function returns true or false depending on whether the transfer was successful. If it failed, we display a message box giving the error:
KMessageBox::error(this, KIO::NetAccess::lastErrorString());

한편, 우리는 연 파일에 대하여 계속 진행한다.

Otherwise, we continue with opening the file.

우리는 NetAccess::download()에 의해 임시 파일을 QFile의 생성자에 넘겨서, QFile의 생성자로 생성하고, 읽기전용 모드로 연다.

We create a QFile by passing the temporary file created by NetAccess::download() to its constructor and then open it in read-only mode
QFile file(tmpFile);

파일의 내용을 보여주기 위하여, 우리는 QTextStream을 사용해야만 한다. {class|QTextStream}}의 생성자에 우리의 파일 내용을 전달함으로써, 이것을 생성하며, 파일으로부터 텍스트를 얻기위해 QFile의 readAll() 함수를 호출한다.이것은 우리의 text area의 setPlainText() 함수에 전달된다.

In order to display the contents of the file, we must use a QTextStream. We create one by passing the contents of our file to its constructor and then call QFile's readAll() function to get the text from the file. This is then passed to the setPlainText() function of our text area.

이제 우리가 열었단 파일 경로를 저장한다.:

We then store the path of the file we just opened:
fileName = fileNameFromDialog;

그리고 마지막으로, NetAccess::download()에 의해 생성된 임시 파일을 삭제한다.

and finally, we remove the temporary file that was created by NetAccess::download():

Make, Install And Run


 1 project(tutorial4)
 3 find_package(KDE4 REQUIRED)
 4 include_directories(${KDE4_INCLUDES})
 6 set(tutorial4_SRCS 
 7   main.cpp
 8   mainwindow.cpp
 9 )
11 kde4_add_executable(tutorial4 ${tutorial4_SRCS})
13 target_link_libraries(tutorial4 ${KDE4_KDEUI_LIBS} 
14                                 ${KDE4_KIO_LIBS})
17 install(FILES tutorial4ui.rc 
18         DESTINATION ${DATA_INSTALL_DIR}/tutorial4)

이제 KIO 라이브러리르 사용하고 있으므로, 이것을 다시 링크하기 위해 우리는 CMake를 실행해야만 한다. ${KDE4_KIO_LIBS}target_link_libraries()에 넣어서 이것을 수행한다.

Since we are now using the KIO library, we must tell CMake to link against it. We do this by passing ${KDE4_KIO_LIBS} to the target_link_libraries() function.

이 파일로 튜트리얼은 빌드 될수 있으며, 튜트리얼3와 같은 방식으로 실행된다. 더 많은 정보를 원하면 튜트리얼 3을 보라.

With this file, the tutorial can built and run in the same way as tutorial 3. For more information, see tutorial 3.
mkdir build && cd build
make install


이제 우리는 KCmdLineArgs 튜트리얼을 진행할 수 있다.

Now you can move on to the KCmdLineArgs tutorial.

This page was last edited on 14 July 2012, at 15:50. Content is available under Creative Commons License SA 4.0 unless otherwise noted.