85328 2004-07-16 13:32:46 +0000 Auto tracking by app not only by desktop 2019-11-12 22:05:10 +0000 1 1 2 Applications ktimetracker general Git (master) unspecified All CLOSED FIXED NOR wishlist --- 1 jpablo ochominutosdearco daniel.vos dev shafff 40 oldest_to_newest 249329 0 jpablo 2004-07-16 13:32:47 +0000 Version: (using KDE KDE 3.2.2) Installed from: RedHat RPMs OS: Linux Auto tracking by desktop is a good idea. I think auto tracking by active application is also util. I want to know the time I spend using kmail, developing in kdevelop or the time spend playing a game. 252683 1 mark 2004-07-25 16:51:10 +0000 Yes, of course. Thanks. 428547 2 dev 2006-04-06 22:00:49 +0000 And what do you want to do if two programs are running ? Sorry, this bug report is not complete - and if it was, I doubt it wouldn't make everything far too complicated. 428648 3 hhielscher 2006-04-07 06:09:07 +0000 The RFE was not about running apps, but about active ones, for me that means tracking the applications that have focus. 501309 4 dev 2007-01-14 00:17:25 +0000 *** Bug 137366 has been marked as a duplicate of this bug. *** 537925 5 dev 2007-07-25 13:31:47 +0000 found someone who is doing it 537931 6 21245 ochominutosdearco 2007-07-25 15:00:04 +0000 Created attachment 21245 patch to autotrack the focused windows and start / restart timers for tasks and stop timers for last focused windows 537934 7 21245 ochominutosdearco 2007-07-25 15:13:20 +0000 Comment on attachment 21245 patch to autotrack the focused windows and start / restart timers for tasks and stop timers for last focused windows Index: taskview.h =================================================================== --- taskview.h (revisión: 692380) +++ taskview.h (copia de trabajo) @@ -30,8 +30,19 @@ #include "desktoplist.h" #include "karmstorage.h" #include "reportcriteria.h" +<<<<<<< .mine +#include "focusdetector.h" +#include <QTimer> +#include <QTableWidget> +#include <QTreeWidget> +======= +>>>>>>> .r692366 +<<<<<<< .mine + +======= class QMouseEvent; +>>>>>>> .r692366 class QString; class QTableWidget; class QTextStream; @@ -39,6 +50,7 @@ class DesktopTracker; class IdleTimeDetector; +class FocusDetector; class Preferences; class Task; class KarmStorage; @@ -138,6 +150,10 @@ /** Calls newTask dialog with caption "New Sub Task". */ void newSubTask(); + /** start the autotracking system to add tasks to control time for every focused windows **/ + void startAutoTracking(); + /** stop the autotracking system to add tasks to control time for every focused windows **/ void stopAutoTracking(); + void editTask(); /** @@ -181,7 +197,7 @@ * @param startTime if taskview has been modified by another program, we have to set the starting time to not-now. */ void startTimerFor( Task* task, QDateTime startTime = QDateTime::currentDateTime() ); - void stopTimerFor( Task* task ); + void stopTimerFor( Task* task ); /** clears all active tasks. Needed e.g. if iCal file was modified by another program and taskview is cleared without stopping tasks @@ -198,8 +214,15 @@ /** Copy history for current and all sub tasks to clipboard. */ QString clipHistory(); +<<<<<<< .mine + + + signals: +======= + Q_SIGNALS: +>>>>>>> .r692366 void totalTimesChanged( long session, long total ); void updateButtons(); void timersActive(); @@ -209,11 +232,13 @@ private: // member variables IdleTimeDetector *_idleTimeDetector; + FocusDetector *_focusDetector; QTimer *_minuteTimer; QTimer *_autoSaveTimer; QTimer *_manualSaveTimer; Preferences *_preferences; QList<Task*> activeTasks; + Task* lastTaskWithFocus; DesktopTracker* _desktopTracker; bool _isloading; Task* dragTask; @@ -236,6 +261,8 @@ void mousePressEvent( QMouseEvent* ); protected Q_SLOTS: + /** newfocuswindowdetected will have the name of that windows at the QString **/ + void newFocusWindowDetected (QString); void autoSaveChanged( bool ); void autoSavePeriodChanged( int period ); void minuteUpdate(); Index: focusdetector.h =================================================================== --- focusdetector.h (revisión: 0) +++ focusdetector.h (revisión: 0) @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2007 René Mérou + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA. + * + * @short Logic that gets and stores tasks from focused windows. + * @author René Mérou <ochominutosdearco@gmail.com> + */ + +#ifndef KARM_IDLE_TIME_DETECTOR_H +#define KARM_IDLE_TIME_DETECTOR_H + +#include <QDateTime> +#include <QObject> +#include "config-karm.h" // HAVE_LIBXSS + +class QTimer; + +//#if defined(HAVE_LIBXSS) && defined(Q_WS_X11) +// #include <X11/Xlib.h> +// #include <X11/Xutil.h> +// #include <X11/extensions/scrnsaver.h> +// #include <fixx11h.h> +//#endif // HAVE_LIBXSS + +const int periodInterval = 1000;//mil veces por segundo y 5 segundos es una vez cada cinco seguntos + +/** + * Keep track of what windonw has the focus. + */ + +class FocusDetector :public QObject +{ +Q_OBJECT + +public: + /** + Initializes the time period + @param periodFocus minutes before every focus detection. + **/ + FocusDetector(int periodFocus); + + /** + Sets the period of time before every focus search. + @param periodFocus period of time in minutes + **/ + void setPeriodFocus(int periodFocus); + + /** + Starts detecting focus + **/ + void startFocusDetection(); + + /** + Stops detecting focus. + **/ + void stopFocusDetection(); + +signals: + + void newFocus(QString); + + + +protected slots: + void check(); + +private: + + int _periodFocus; + QTimer *_timer; + QDateTime start; // when the periodFocus restarted + +}; + +#endif // KARM_IDLE_TIME_DETECTOR_H Index: taskview.cpp =================================================================== --- taskview.cpp (revisión: 692380) +++ taskview.cpp (copia de trabajo) @@ -34,6 +34,15 @@ #include <QList> #include <QListWidget> +<<<<<<< .mine +#include <kapplication.h> // kapp con < > y no con "" +#include <kconfig.h> +#include <kdebug.h> +#include <kfiledialog.h> +#include <klocale.h> // i18n +#include <kmessagebox.h> +#include <kurlrequester.h> +======= #include <KApplication> // kapp #include <KConfig> #include <KDebug> @@ -41,11 +50,17 @@ #include <KLocale> // i18n #include <KMessageBox> #include <KUrlRequester> +>>>>>>> .r692366 #include "csvexportdialog.h" #include "desktoptracker.h" #include "edittaskdialog.h" #include "idletimedetector.h" +<<<<<<< .mine +#include "focusdetector.h" +#include "karmstorage.h" +======= +>>>>>>> .r692366 #include "plannerparser.h" #include "preferences.h" #include "printdialog.h" @@ -116,6 +131,7 @@ this, SLOT(slotItemDoubleClicked(QTreeWidgetItem*, int)) ); QStringList labels; + QString namewindowfocus; labels << i18n("Task Name") << i18n("Session Time") << i18n("Time") << i18n("Total Session Time") << i18n("Total Time") << i18n("Percent Complete") ; setHeaderLabels(labels); headerItem()->setWhatsThis(0,"The task name is how you call the task, it can be chose freely."); @@ -140,23 +156,22 @@ // Set up the idle detection. _idleTimeDetector = new IdleTimeDetector( _preferences->idlenessTimeout() ); - connect( _idleTimeDetector, SIGNAL( extractTime(int) ), - this, SLOT( extractTime(int) )); - connect( _idleTimeDetector, SIGNAL( stopAllTimers(QDateTime) ), - this, SLOT( stopAllTimers(QDateTime) )); - connect( _preferences, SIGNAL( idlenessTimeout(int) ), - _idleTimeDetector, SLOT( setMaxIdle(int) )); - connect( _preferences, SIGNAL( detectIdleness(bool) ), - _idleTimeDetector, SLOT( toggleOverAllIdleDetection(bool) )); - if (!_idleTimeDetector->isIdleDetectionPossible()) - _preferences->disableIdleDetection(); + connect( _idleTimeDetector, SIGNAL( extractTime(int) ), this, SLOT( extractTime(int) )); + connect( _idleTimeDetector, SIGNAL( stopAllTimers(QDateTime) ), this, SLOT( stopAllTimers(QDateTime) )); + connect( _preferences, SIGNAL( idlenessTimeout(int) ), _idleTimeDetector, SLOT( setMaxIdle(int) )); + connect( _preferences, SIGNAL( detectIdleness(bool) ), _idleTimeDetector, SLOT( toggleOverAllIdleDetection(bool) )); + if (!_idleTimeDetector->isIdleDetectionPossible()) _preferences->disableIdleDetection(); + +// Set up the focus detection. + _focusDetector = new FocusDetector(30); + connect( _focusDetector, SIGNAL( newFocus(QString) ), this, SLOT( newFocusWindowDetected (QString) )); + // Setup auto save timer _autoSaveTimer = new QTimer(this); connect( _preferences, SIGNAL( autoSave(bool) ), this, SLOT( autoSaveChanged(bool) )); - connect( _preferences, SIGNAL( autoSavePeriod(int) ), - this, SLOT( autoSavePeriodChanged(int) )); + connect( _preferences, SIGNAL( autoSavePeriod(int) ),this, SLOT( autoSavePeriodChanged(int) )); connect( _autoSaveTimer, SIGNAL( timeout() ), this, SLOT( save() )); // Setup manual save timer (to save changes a little while after they happen) @@ -536,7 +551,14 @@ void TaskView::startTimerFor(Task* task, QDateTime startTime ) { +<<<<<<< .mine + kDebug(5970) << "Entering TaskView::startTimerFor" << endl; + + _focusDetector->startFocusDetection(); + if (task != 0 && activeTasks.findRef(task) == -1) +======= if (task != 0 && activeTasks.indexOf(task) == -1) +>>>>>>> .r692366 { if (_preferences->uniTasking()) stopAllTimers(); _idleTimeDetector->startIdleDetection(); @@ -552,7 +574,11 @@ void TaskView::clearActiveTasks() { + kDebug(5970) << "Entering TaskView::clearActiveTasks" << endl; activeTasks.clear(); + _focusDetector->startFocusDetection(); + + } void TaskView::stopAllTimers( QDateTime when ) @@ -562,6 +588,7 @@ activeTasks.at(i)->setRunning(false, _storage, when); _idleTimeDetector->stopIdleDetection(); + _focusDetector->stopFocusDetection(); activeTasks.clear(); emit updateButtons(); emit timersInactive(); @@ -655,6 +682,8 @@ desktopList.clear(); QString uid = addTask( taskName, total, session, desktopList, parent ); + //kDebug(5970) << "addTask taskname = " << taskName << "total:" << total << "totaldif:" << totalDiff << "sesion:" << session << "sesiondif:" << sessionDiff << "desktopList" << desktopList << endl; + if ( uid.isNull() ) { KMessageBox::error( 0, i18n( @@ -861,6 +890,59 @@ autoSaveChanged(_preferences->autoSave()); } +void TaskView::newFocusWindowDetected(const QString taskName) +{ + const DesktopList desktopList; + Task* task=0; + QString rval=""; + QString taskuid; + stopTimerFor(lastTaskWithFocus); + int i=0; + for ( Task* task3 = item_at_index(i); task3; task3 = item_at_index(++i) ) + { + //kDebug(5970) << "seen this task = -" << task3->name() << "-" << taskName << "-"<< endl; + if (task3->name()==taskName) + { + rval="inside"; + //kDebug(5970) << "this task has same codename " << taskName << " " << task3->name() << endl; + startTimerFor(task3); + lastTaskWithFocus=task3; + } + } + if (rval=="") + { + //kDebug(5970) << "there is not task with that codename " << taskName << endl; + taskuid= addTask(taskName, 0L, 0L, desktopList, task ); + if ( taskuid.isNull() ) + { + KMessageBox::error( 0, i18n( + "Error storing new task. Your changes were not saved. Make sure you can edit your iCalendar file. Also quit all applications using this file and remove any lock file related to its name from ~/.kde/share/apps/kabc/lock/ " ) ); + } + i=0; + for ( Task* task3 = item_at_index(i); task3; task3 = item_at_index(++i) ) + { + //kDebug(5970) << "seen this task (not here) -" << task3->name() << "-" << taskName << "-"<< endl; + + if (task3->name()==taskName) + { + rval="inside"; + //kDebug(5970) << "the task is here = " << taskName << " " << task3->name() << endl; + startTimerFor(task3); + lastTaskWithFocus=task3; + } + } + } + i=0; + //kDebug(5970) << "list of tasks -" << task3->name() << "-" << taskName << "-"<< endl; + //for ( Task* task3 = item_at_index(i); task3; task3 = item_at_index(++i) ) + // { + // kDebug(5970) << "task: -" << task3->name() << "-" << taskName << "-"<< endl; + // } + emit updateButtons(); +} + + + void TaskView::adaptColumns() /* This procedure adapts the columns, it can e.g. be called when the user changes the time format or requests to hide some columns. Index: focusdetector.cpp =================================================================== --- focusdetector.cpp (revisión: 0) +++ focusdetector.cpp (revisión: 0) @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2007 René Mérou + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA. + * + * @short Logic that gets and stores tasks from focused windows. + * @author René Mérou <ochominutosdearco@gmail.com> + */ +#include <QProcess> +#include "focusdetector.h" + +#include <qdatetime.h> +#include <qmessagebox.h> +#include <qtimer.h> + +#include <kdialog.h> +#include <kglobal.h> +#include <klocale.h> // i18n +#include <QLabel> +#include <QHBoxLayout> +#include <QVBoxLayout> +#ifdef Q_WS_X11 +#include <QX11Info> +#endif + QString lastWindow=""; +FocusDetector::FocusDetector(int periodFocus) +{ + _timer = new QTimer(this); + connect(_timer, SIGNAL(timeout()), this, SLOT(check())); + _timer->start(1000*periodFocus); +} + +void FocusDetector::check() +{ + QProcess focusQuestion; + QString mensaje="xprop -root"; + QString trozo1,trozo2,trozo3; + QString cadena="_NET_ACTIVE_WINDOW(WINDOW): window id # "; + + focusQuestion.setProcessChannelMode(QProcess::MergedChannels); + focusQuestion.start( mensaje ); + + if (!focusQuestion.waitForFinished()) + qDebug() << "Make failed:" << focusQuestion.errorString(); + else + trozo1=focusQuestion.readAll(); + trozo3=trozo1.mid(trozo1.lastIndexOf(cadena)+40,9); + trozo3="xwininfo -id " + trozo3; + focusQuestion.start(trozo3); + if (!focusQuestion.waitForFinished()) + qDebug() << "Make failed:" << focusQuestion.errorString(); + else + trozo1=focusQuestion.readAll(); + trozo2=trozo1.mid(trozo1.lastIndexOf("Window id")+22,200); + trozo3=trozo2.left( trozo2.indexOf("Absolute upper-left X")-5); + if (lastWindow!=trozo3) { + lastWindow=trozo3; + qDebug() << "NEW WINDOW WITH FOCUS; Sending signal:" << trozo3 << endl; + emit (newFocus(trozo3)); + } +} + +void FocusDetector::setPeriodFocus(int periodFocus) +{ + _periodFocus = periodFocus; +} + +void FocusDetector::startFocusDetection() +{ + if (!_timer->isActive()) + _timer->start(periodInterval); +} + +void FocusDetector::stopFocusDetection() +{ + if (_timer->isActive()) + _timer->stop(); +} + +#include "focusdetector.moc" Index: mainwindow.cpp =================================================================== --- mainwindow.cpp (revisión: 692380) +++ mainwindow.cpp (copia de trabajo) @@ -159,7 +159,20 @@ saveGeometry(); return true; } +void MainWindow::topWindowTracker() +{ + int a=0; + kDebug(5970) << "entro en topWindowTracker." << endl; + //statusBar()->showMessage(i18n("pase por aqui"),1807); + statusBar()->showMessage(i18n("Successfullyy saved tasks and history"),1807); + while (a<1000){ + a=a+1; + statusBar()->showMessage(i18n("Successfullyyyy saved tasks and history"),1807); + //statusBar()->showMessage(i18n("pase por aqui %i"),1807,a); + } +} + void MainWindow::exportcsvHistory() { kDebug(5970) << "Exporting History to disk." << endl; Index: idletimedetector.h =================================================================== --- idletimedetector.h (revisión: 692380) +++ idletimedetector.h (copia de trabajo) @@ -19,8 +19,8 @@ * */ -#ifndef KARM_IDLE_TIME_DETECTOR_H -#define KARM_IDLE_TIME_DETECTOR_H +#ifndef KARM_FOCUS_DETECTOR_H +#define KARM_FOCUS_DETECTOR_H #include <QDateTime> #include <QObject> @@ -112,6 +112,9 @@ protected Q_SLOTS: void check(); + signals: + void focusChanged(); + private: #if defined(HAVE_LIBXSS) && defined(Q_WS_X11) XScreenSaverInfo *_mit_info; Index: mainwindow.h =================================================================== --- mainwindow.h (revisión: 692380) +++ mainwindow.h (copia de trabajo) @@ -102,6 +102,8 @@ QString setpromptdelete( bool prompt ); QString exportcsvfile( QString filename, QString from, QString to, int type, bool decimalMinutes, bool allTasks, QString delimiter, QString quote ); QString importplannerfile( QString filename ); + /** test topwindowtracker */ + void topWindowTracker(); public Q_SLOTS: void setStatusBar( const QString& ); @@ -109,7 +111,13 @@ void quit(); /** Save the calendar */ bool save(); +<<<<<<< .mine + + + protected slots: +======= protected Q_SLOTS: +>>>>>>> .r692366 void keyBindings(); void startNewSession(); void resetAllTimes(); Index: main.cpp =================================================================== --- main.cpp (revisión: 692380) +++ main.cpp (copia de trabajo) @@ -56,6 +56,7 @@ aboutData.addAuthor( ki18n("Jesper Pedersen"), KLocalizedString(), "blackie@kde.org" ); aboutData.addAuthor( ki18n("Kalle Dalheimer"), KLocalizedString(), "kalle@kde.org" ); aboutData.addAuthor( ki18n("Mark Bucciarelli"), KLocalizedString(), "mark@hubcapconsulting.com" ); + aboutData.addAuthor( ki18n("René Mérou"), KLocalizedString(), "ochominutosdearco@gmail.com" ); KCmdLineArgs::init( argc, argv, &aboutData ); Index: CMakeLists.txt =================================================================== --- CMakeLists.txt (revisión: 692380) +++ CMakeLists.txt (copia de trabajo) @@ -13,7 +13,7 @@ ########### next target ############### set(karm_shared_SRCS kaccelmenuwatch.cpp desktoptracker.cpp - edittaskdialog.cpp idletimedetector.cpp + edittaskdialog.cpp idletimedetector.cpp focusdetector.cpp printdialog.cpp timekard.cpp karmutility.cpp ktimewidget.cpp karmstorage.cpp mainwindow.cpp preferences.cpp print.cpp task.cpp taskview.cpp tray.cpp 538155 8 dev 2007-07-26 23:02:35 +0000 please also paste the patch's implementation of startautotracking and stopautotracking. 538190 9 21258 dev 2007-07-27 06:19:39 +0000 Created attachment 21258 please base your development on this patch from now on guy, that's amazing. It works. I have never had so much fun testing out a patch - to see it just work is unbelievable. Good work, trebol, I had'nt thought a beginner would be able to make it. I refined your patch and attached it, it does no longer contain any conflicts, it compiles and is taken against the latest version. However, still some refinements needed. 538191 10 21259 dev 2007-07-27 07:04:44 +0000 Created attachment 21259 code cleanUp 538200 11 dev 2007-07-27 07:46:48 +0000 I do not like focusdetector.cpp, in principle, you do not more than executing xwininfo -id $(xprop -root | grep "NET_ACTIVE_WINDOW(WINDOW):" | sed "s/_NET_ACTIVE_WINDOW(WINDOW): window id # //") | grep xwininfo | sed "s/xwininfo: Window id: 0x[0-9a-f]* //" and you should also show this and make the string configurable. 538208 12 21263 dev 2007-07-27 09:59:41 +0000 Created attachment 21263 this time I forgot to svn add some files 538213 13 dev 2007-07-27 10:53:10 +0000 SVN commit 693146 by tstaerk: Allow tracking your time by focus on applications. BUGS:85328 M +1 -1 CMakeLists.txt A focusdetector.cpp [License: GPL (v2+)] A focusdetector.h [License: GPL (v2+)] AM getactivewindowtitle M +1 -0 karmui.rc M +6 -1 mainwindow.cpp M +53 -1 taskview.cpp M +20 -2 taskview.h --- trunk/KDE/kdepim/ktimetracker/CMakeLists.txt #693145:693146 @@ -16,7 +16,7 @@ edittaskdialog.cpp idletimedetector.cpp printdialog.cpp timekard.cpp karmutility.cpp ktimewidget.cpp karmstorage.cpp mainwindow.cpp preferences.cpp print.cpp - task.cpp taskview.cpp tray.cpp + task.cpp taskview.cpp tray.cpp focusdetector.cpp csvexportdialog.cpp plannerparser.cpp treeviewheadercontextmenu.cpp edithistorydialog.cpp ) ** trunk/KDE/kdepim/ktimetracker/getactivewindowtitle #property svn:executable + * --- trunk/KDE/kdepim/ktimetracker/karmui.rc #693145:693146 @@ -15,6 +15,7 @@ <Action name="start" /> <Action name="stop" /> <Action name="stopAll" /> + <Action name="focustracking" /> </Menu> <Menu name="task" > <text>&amp;Task</text> --- trunk/KDE/kdepim/ktimetracker/mainwindow.cpp #693145:693146 @@ -313,7 +313,7 @@ actionStop->setShortcut(QKeySequence(Qt::Key_S)); actionStop->setToolTip( i18n("Stop timing of the selected task") ); actionStop->setWhatsThis( i18n("Stop timing of the selected task") ); - + // Stop all timers actionStopAll = new KAction(i18n("Stop &All Timers"), this); actionCollection()->addAction("stopAll", actionStopAll ); @@ -323,6 +323,11 @@ actionStopAll->setToolTip( i18n("Stop all of the active timers") ); actionStopAll->setWhatsThis( i18n("Stop all of the active timers") ); + // Focus tracking + QAction* actionFocusTracking = new KAction(i18n("Track active applications"), this); + actionCollection()->addAction("focustracking", actionFocusTracking ); + connect(actionFocusTracking, SIGNAL(triggered(bool)), _taskView, SLOT( slotfocustracking())); + // New task actionNew = new KAction(KIcon(QString::fromLatin1("document-new")), i18n("&New..."), this); actionCollection()->addAction("new_task", actionNew ); --- trunk/KDE/kdepim/ktimetracker/taskview.cpp #693145:693146 @@ -107,6 +107,8 @@ { _preferences = Preferences::instance( icsfile ); _storage = KarmStorage::instance(); + _focusDetector = new FocusDetector(1); + focustrackingactive = false; connect( this, SIGNAL(itemExpanded(QTreeWidgetItem*)), this, SLOT(itemStateChanged(QTreeWidgetItem*)) ); @@ -114,6 +116,8 @@ this, SLOT(itemStateChanged(QTreeWidgetItem*)) ); connect( this, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), this, SLOT(slotItemDoubleClicked(QTreeWidgetItem*, int)) ); + connect( _focusDetector, SIGNAL( newFocus(QString) ), + this, SLOT(newFocusWindowDetected (QString)) ); QStringList labels; labels << i18n("Task Name") << i18n("Session Time") << i18n("Time") << i18n("Total Session Time") << i18n("Total Time") << i18n("Percent Complete") ; @@ -179,6 +183,47 @@ connect( headerContextMenu, SIGNAL(columnToggled(int)), this, SLOT(slotColumnToggled(int)) ); } +void TaskView::newFocusWindowDetected(const QString taskName) +{ + if (focustrackingactive) + { + bool found=false; // has taskName been found in our tasks + stopTimerFor(lastTaskWithFocus); + int i=0; + for ( Task* task = item_at_index(i); task; task = item_at_index(++i) ) + { + QString q1=taskName; + q1.replace("\n",""); + if (q1==task->name()) + { + found=true; + startTimerFor(task); + lastTaskWithFocus=task; + } + } + if (!found) + { + QString taskuid = addTask( taskName ); + if ( taskuid.isNull() ) + { + KMessageBox::error( 0, i18n( + "Error storing new task. Your changes were not saved. Make sure you can edit your iCalendar file. Also quit all applications using this file and remove any lock file related to its name from ~/.kde/share/apps/kabc/lock/ " ) ); + } + i=0; + for ( Task* task = item_at_index(i); task; task = item_at_index(++i) ) + { + if (task->name()==taskName) + { + startTimerFor(task); + lastTaskWithFocus=task; + } + } + } + emit updateButtons(); + } // focustrackingactive +} + + void TaskView::dropEvent(QDropEvent* qde) { kDebug(5970) << "This is dropEvent" << endl; @@ -552,7 +597,8 @@ void TaskView::clearActiveTasks() { - activeTasks.clear(); + activeTasks.clear(); + _focusDetector->startFocusDetection(); } void TaskView::stopAllTimers( QDateTime when ) @@ -562,12 +608,18 @@ activeTasks.at(i)->setRunning(false, _storage, when); _idleTimeDetector->stopIdleDetection(); + _focusDetector->stopFocusDetection(); activeTasks.clear(); emit updateButtons(); emit timersInactive(); emit tasksChanged( activeTasks); } +void TaskView::slotfocustracking() +{ + focustrackingactive=true; +} + void TaskView::startNewSession() /* This procedure starts a new session. Technically, a session is just an additionally stored time that is always contain in the overall time. We speak of session times, --- trunk/KDE/kdepim/ktimetracker/taskview.h #693145:693146 @@ -30,6 +30,7 @@ #include "desktoplist.h" #include "karmstorage.h" #include "reportcriteria.h" +#include "focusdetector.h" class QMouseEvent; class QString; @@ -92,7 +93,7 @@ Preferences *preferences(); /** Add a task to view and storage. */ - QString addTask( const QString& taskame, long total, long session, const DesktopList& desktops, + QString addTask( const QString& taskame, long total = 0, long session = 0, const DesktopList& desktops = QVector<int>(0,0), Task* parent = 0 ); public Q_SLOTS: @@ -111,6 +112,8 @@ */ void stopAllTimers(QDateTime when=QDateTime::currentDateTime()); + void slotfocustracking(); + /** Calls newTask dialog with caption "New Task". */ void newTask(); @@ -138,6 +141,12 @@ /** Calls newTask dialog with caption "New Sub Task". */ void newSubTask(); + /** start the autotracking system to add tasks to control time for every focused windows **/ + void startAutoTracking(){}; + + /** stop the autotracking system to add tasks to control time for every focused windows **/ + void stopAutoTracking(){}; + void editTask(); /** @@ -208,7 +217,9 @@ void setStatusBarText(QString); private: // member variables - IdleTimeDetector *_idleTimeDetector; + IdleTimeDetector* _idleTimeDetector; + FocusDetector* _focusDetector; + bool focustrackingactive; // do we track by which application has the focus ? QTimer *_minuteTimer; QTimer *_autoSaveTimer; QTimer *_manualSaveTimer; @@ -218,6 +229,7 @@ bool _isloading; Task* dragTask; QTableWidget* historywidget; + Task* lastTaskWithFocus; //KCal::CalendarLocal _calendar; KarmStorage * _storage; @@ -239,12 +251,18 @@ void autoSaveChanged( bool ); void autoSavePeriodChanged( int period ); void minuteUpdate(); + /** item state stores if a task is expanded so you can see the subtasks */ void itemStateChanged( QTreeWidgetItem *item ); + /** React on another process having modified the iCal file we rely on. This is not iCalFileChanged. */ void iCalFileModified(ResourceCalendar *); void slotItemDoubleClicked( QTreeWidgetItem *item, int ); + + /** React on the focus having changed to Window QString **/ + void newFocusWindowDetected (QString); + void slotColumnToggled( int ); }; 538235 14 ochominutosdearco 2007-07-27 13:01:39 +0000 "I do not like focusdetector.cpp, in principle, you do not more than executing ..." Yes, this is not the best solution. It just do the job with not too much cpu work. The best way to solve it is to say (DBUSS / X server / anyother) to inform of the event "new focused window with name:XXX" i was not able to find that. Now some improvements ideas are: 1-to add one buton to delete all tasks with les than one minute. 2-to add the other button to stop/restart focus detection. 3-To add one preference for period of time to check that can be sected from: 0 seconds (autotracking all focused, in one core2duo it charges cpu to 7% ) or select 1...100 seconds betwing every check. Now default is 30 seconds, i have seen that 0 secs can add too much 0m. tasks 538444 15 21282 dev 2007-07-28 19:34:27 +0000 Created attachment 21282 now in C code, not in bash 539312 16 dev 2007-08-03 08:01:47 +0000 > Now some improvements ideas are: This bug is closed, new ideas will not be taken from here 1891234 17 aspotashev 2019-11-12 22:05:10 +0000 *** Bug 154506 has been marked as a duplicate of this bug. *** 21245 2007-07-25 15:00:04 +0000 2007-07-27 06:19:40 +0000 patch to autotrack the focused windows and start / restart timers for tasks and stop timers for last focused windows patch.txt text/plain 18454 ochominutosdearco SW5kZXg6IHRhc2t2aWV3LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gdGFza3ZpZXcuaCAgKHJldmlzacOzbjog NjkyMzY2KQorKysgdGFza3ZpZXcuaCAgKGNvcGlhIGRlIHRyYWJham8pCkBAIC0zMCw4ICszMCwx OSBAQAogI2luY2x1ZGUgImRlc2t0b3BsaXN0LmgiCiAjaW5jbHVkZSAia2FybXN0b3JhZ2UuaCIK ICNpbmNsdWRlICJyZXBvcnRjcml0ZXJpYS5oIgorPDw8PDw8PCAubWluZQorI2luY2x1ZGUgImZv Y3VzZGV0ZWN0b3IuaCIKKyNpbmNsdWRlIDxRVGltZXI+CisjaW5jbHVkZSA8UVRhYmxlV2lkZ2V0 PgorI2luY2x1ZGUgPFFUcmVlV2lkZ2V0PgorPT09PT09PQorPj4+Pj4+PiAucjY5MjM2NgoKKzw8 PDw8PDwgLm1pbmUKKworPT09PT09PQogY2xhc3MgUU1vdXNlRXZlbnQ7Cis+Pj4+Pj4+IC5yNjky MzY2CiBjbGFzcyBRU3RyaW5nOwogY2xhc3MgUVRhYmxlV2lkZ2V0OwogY2xhc3MgUVRleHRTdHJl YW07CkBAIC0zOSw2ICs1MCw3IEBACgogY2xhc3MgRGVza3RvcFRyYWNrZXI7CiBjbGFzcyBJZGxl VGltZURldGVjdG9yOworY2xhc3MgRm9jdXNEZXRlY3RvcjsKIGNsYXNzIFByZWZlcmVuY2VzOwog Y2xhc3MgVGFzazsKIGNsYXNzIEthcm1TdG9yYWdlOwpAQCAtMTM4LDYgKzE1MCwxMCBAQAogICAg IC8qKiBDYWxscyBuZXdUYXNrIGRpYWxvZyB3aXRoIGNhcHRpb24gIk5ldyBTdWIgVGFzayIuICov CiAgICAgdm9pZCBuZXdTdWJUYXNrKCk7CgorICAgIC8qKiBzdGFydCB0aGUgYXV0b3RyYWNraW5n IHN5c3RlbSB0byBhZGQgdGFza3MgdG8gY29udHJvbCB0aW1lIGZvciBldmVyeSBmb2N1c2VkIHdp bmRvd3MgKiovCisgICAgdm9pZCBzdGFydEF1dG9UcmFja2luZygpOworICAgIC8qKiBzdG9wIHRo ZSBhdXRvdHJhY2tpbmcgc3lzdGVtIHRvIGFkZCB0YXNrcyB0byBjb250cm9sIHRpbWUgZm9yIGV2 ZXJ5IGZvY3VzZWQgd2luZG93cyAqKi8gICAgdm9pZCBzdG9wQXV0b1RyYWNraW5nKCk7CisKICAg ICB2b2lkIGVkaXRUYXNrKCk7CgogICAgIC8qKgpAQCAtMTgxLDcgKzE5Nyw3IEBACiAgICAgICog QHBhcmFtIHN0YXJ0VGltZSBpZiB0YXNrdmlldyBoYXMgYmVlbiBtb2RpZmllZCBieSBhbm90aGVy IHByb2dyYW0sIHdlCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaGF2ZSB0byBzZXQgdGhl IHN0YXJ0aW5nIHRpbWUgdG8gbm90LW5vdy4gKi8KICAgICB2b2lkIHN0YXJ0VGltZXJGb3IoIFRh c2sqIHRhc2ssIFFEYXRlVGltZSBzdGFydFRpbWUgPSBRRGF0ZVRpbWU6OmN1cnJlbnREYXRlVGlt ZSgpICk7Ci0gICAgIHZvaWQgc3RvcFRpbWVyRm9yKCBUYXNrKiB0YXNrICk7CisgICAgdm9pZCAg c3RvcFRpbWVyRm9yKCBUYXNrKiB0YXNrICk7CgogICAgIC8qKiBjbGVhcnMgYWxsIGFjdGl2ZSB0 YXNrcy4gTmVlZGVkIGUuZy4gaWYgaUNhbCBmaWxlIHdhcyBtb2RpZmllZCBieQogICAgICAgIGFu b3RoZXIgcHJvZ3JhbSBhbmQgdGFza3ZpZXcgaXMgY2xlYXJlZCB3aXRob3V0IHN0b3BwaW5nIHRh c2tzCkBAIC0xOTgsOCArMjE0LDE1IEBACgogICAgIC8qKiBDb3B5IGhpc3RvcnkgZm9yIGN1cnJl bnQgYW5kIGFsbCBzdWIgdGFza3MgdG8gY2xpcGJvYXJkLiAqLwogICAgIFFTdHJpbmcgY2xpcEhp c3RvcnkoKTsKKzw8PDw8PDwgLm1pbmUKCisKKworICBzaWduYWxzOgorPT09PT09PQorCiAgIFFf U0lHTkFMUzoKKz4+Pj4+Pj4gLnI2OTIzNjYKICAgICB2b2lkIHRvdGFsVGltZXNDaGFuZ2VkKCBs b25nIHNlc3Npb24sIGxvbmcgdG90YWwgKTsKICAgICB2b2lkIHVwZGF0ZUJ1dHRvbnMoKTsKICAg ICB2b2lkIHRpbWVyc0FjdGl2ZSgpOwpAQCAtMjA5LDExICsyMzIsMTMgQEAKCiAgIHByaXZhdGU6 IC8vIG1lbWJlciB2YXJpYWJsZXMKICAgICBJZGxlVGltZURldGVjdG9yICpfaWRsZVRpbWVEZXRl Y3RvcjsKKyAgICBGb2N1c0RldGVjdG9yICpfZm9jdXNEZXRlY3RvcjsKICAgICBRVGltZXIgKl9t aW51dGVUaW1lcjsKICAgICBRVGltZXIgKl9hdXRvU2F2ZVRpbWVyOwogICAgIFFUaW1lciAqX21h bnVhbFNhdmVUaW1lcjsKICAgICBQcmVmZXJlbmNlcyAqX3ByZWZlcmVuY2VzOwogICAgIFFMaXN0 PFRhc2sqPiBhY3RpdmVUYXNrczsKKyAgICBUYXNrKiAgbGFzdFRhc2tXaXRoRm9jdXM7CiAgICAg RGVza3RvcFRyYWNrZXIqIF9kZXNrdG9wVHJhY2tlcjsKICAgICBib29sIF9pc2xvYWRpbmc7CiAg ICAgVGFzayogZHJhZ1Rhc2s7CkBAIC0yMzYsNiArMjYxLDggQEAKICAgICB2b2lkIG1vdXNlUHJl c3NFdmVudCggUU1vdXNlRXZlbnQqICk7CgogICBwcm90ZWN0ZWQgUV9TTE9UUzoKKyAgICAvKiog bmV3Zm9jdXN3aW5kb3dkZXRlY3RlZCB3aWxsIGhhdmUgdGhlIG5hbWUgb2YgdGhhdCB3aW5kb3dz IGF0IHRoZSBRU3RyaW5nICoqLworICAgIHZvaWQgbmV3Rm9jdXNXaW5kb3dEZXRlY3RlZCAoUVN0 cmluZyk7CiAgICAgdm9pZCBhdXRvU2F2ZUNoYW5nZWQoIGJvb2wgKTsKICAgICB2b2lkIGF1dG9T YXZlUGVyaW9kQ2hhbmdlZCggaW50IHBlcmlvZCApOwogICAgIHZvaWQgbWludXRlVXBkYXRlKCk7 CkluZGV4OiBmb2N1c2RldGVjdG9yLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gZm9jdXNkZXRlY3Rvci5oICAg ICAocmV2aXNpw7NuOiAwKQorKysgZm9jdXNkZXRlY3Rvci5oICAgICAocmV2aXNpw7NuOiAwKQpA QCAtMCwwICsxLDkwIEBACisvKgorICogICAgIENvcHlyaWdodCAoQykgMjAwNyB0aGUga3RpbWV0 cmFja2VyIGRldmVsb3BlcnMKKyAqCisgKiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgKiAgIGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 CisgKiAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2Yg dGhlIExpY2Vuc2UsIG9yCisgKiAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisgKgorICogICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogICBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICAgWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYWxv bmcKKyAqICAgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlCisgKiAgICAg IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLgorICogICAgICA1MSBGcmFua2xpbiBTdHJl ZXQsIEZpZnRoIEZsb29yCisgKiAgICAgIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQS4KKyAq CisgKiBAc2hvcnQgTG9naWMgdGhhdCBnZXRzIGFuZCBzdG9yZXMgdGFza3MgZnJvbSBmb2N1c2Vk IHdpbmRvd3MuCisgKiBAYXV0aG9yIFJlbsOpIE3DqXJvdSA8b2Nob21pbnV0b3NkZWFyY29AZ21h aWwuY29tPgorICovCisKKyNpZm5kZWYgS0FSTV9JRExFX1RJTUVfREVURUNUT1JfSAorI2RlZmlu ZSBLQVJNX0lETEVfVElNRV9ERVRFQ1RPUl9ICisKKyNpbmNsdWRlIDxRRGF0ZVRpbWU+CisjaW5j bHVkZSA8UU9iamVjdD4KKyNpbmNsdWRlICJjb25maWcta2FybS5oIiAvLyBIQVZFX0xJQlhTUwor CitjbGFzcyBRVGltZXI7CisKKy8vI2lmIGRlZmluZWQoSEFWRV9MSUJYU1MpICYmIGRlZmluZWQo UV9XU19YMTEpCisvLyAjaW5jbHVkZSA8WDExL1hsaWIuaD4KKy8vICNpbmNsdWRlIDxYMTEvWHV0 aWwuaD4KKy8vICNpbmNsdWRlIDxYMTEvZXh0ZW5zaW9ucy9zY3Juc2F2ZXIuaD4KKy8vICNpbmNs dWRlIDxmaXh4MTFoLmg+CisvLyNlbmRpZiAvLyBIQVZFX0xJQlhTUworCitjb25zdCBpbnQgcGVy aW9kSW50ZXJ2YWwgPSAxMDAwOy8vbWlsIHZlY2VzIHBvciBzZWd1bmRvIHkgNSBzZWd1bmRvcyAg ZXMgdW5hIHZleiBjYWRhIGNpbmNvIHNlZ3VudG9zCisKKy8qKgorICogS2VlcCB0cmFjayBvZiB3 aGF0IHdpbmRvbncgaGFzIHRoZSBmb2N1cy4KKyAqLworCitjbGFzcyBGb2N1c0RldGVjdG9yIDpw dWJsaWMgUU9iamVjdAoreworUV9PQkpFQ1QKKworcHVibGljOgorICAvKioKKyAgICAgSW5pdGlh bGl6ZXMgdGhlIHRpbWUgcGVyaW9kCisgICAgIEBwYXJhbSBwZXJpb2RGb2N1cyBtaW51dGVzIGJl Zm9yZSBldmVyeSBmb2N1cyBkZXRlY3Rpb24uCisgICoqLworICBGb2N1c0RldGVjdG9yKGludCBw ZXJpb2RGb2N1cyk7CisKKyAgLyoqCisgICAgIFNldHMgdGhlIHBlcmlvZCBvZiB0aW1lIGJlZm9y ZSBldmVyeSBmb2N1cyBzZWFyY2guCisgICAgIEBwYXJhbSBwZXJpb2RGb2N1cyBwZXJpb2Qgb2Yg dGltZSBpbiBtaW51dGVzCisgICoqLworICB2b2lkIHNldFBlcmlvZEZvY3VzKGludCBwZXJpb2RG b2N1cyk7CisKKyAgLyoqCisgICAgIFN0YXJ0cyBkZXRlY3RpbmcgZm9jdXMKKyAgKiovCisgIHZv aWQgc3RhcnRGb2N1c0RldGVjdGlvbigpOworCisgIC8qKgorICAgICAgU3RvcHMgZGV0ZWN0aW5n IGZvY3VzLgorICAqKi8KKyAgdm9pZCBzdG9wRm9jdXNEZXRlY3Rpb24oKTsKKworc2lnbmFsczoK KworICAgIHZvaWQgbmV3Rm9jdXMoUVN0cmluZyk7CisKKworCitwcm90ZWN0ZWQgc2xvdHM6Cisg IHZvaWQgY2hlY2soKTsKKworcHJpdmF0ZToKKworICBpbnQgX3BlcmlvZEZvY3VzOworICBRVGlt ZXIgKl90aW1lcjsKKyAgUURhdGVUaW1lIHN0YXJ0OyAvLyB3aGVuIHRoZSBwZXJpb2RGb2N1cyBy ZXN0YXJ0ZWQKKworfTsKKworI2VuZGlmIC8vIEtBUk1fSURMRV9USU1FX0RFVEVDVE9SX0gKSW5k ZXg6IHRhc2t2aWV3LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSB0YXNrdmlldy5jcHAgICAgICAgIChyZXZp c2nDs246IDY5MjM2NikKKysrIHRhc2t2aWV3LmNwcCAgICAgICAgKGNvcGlhIGRlIHRyYWJham8p CkBAIC0zNCw2ICszNCwxNSBAQAogI2luY2x1ZGUgPFFMaXN0PgogI2luY2x1ZGUgPFFMaXN0V2lk Z2V0PgoKKzw8PDw8PDwgLm1pbmUKKyNpbmNsdWRlIDxrYXBwbGljYXRpb24uaD4gICAgICAgLy8g a2FwcCAgY29uIDwgPiB5IG5vIGNvbiAiIgorI2luY2x1ZGUgPGtjb25maWcuaD4KKyNpbmNsdWRl IDxrZGVidWcuaD4KKyNpbmNsdWRlIDxrZmlsZWRpYWxvZy5oPgorI2luY2x1ZGUgPGtsb2NhbGUu aD4gICAgICAgICAgICAvLyBpMThuCisjaW5jbHVkZSA8a21lc3NhZ2Vib3guaD4KKyNpbmNsdWRl IDxrdXJscmVxdWVzdGVyLmg+Cis9PT09PT09CiAjaW5jbHVkZSA8S0FwcGxpY2F0aW9uPiAgICAg ICAvLyBrYXBwCiAjaW5jbHVkZSA8S0NvbmZpZz4KICNpbmNsdWRlIDxLRGVidWc+CkBAIC00MSwx MSArNTAsMTcgQEAKICNpbmNsdWRlIDxLTG9jYWxlPiAgICAgICAgICAgIC8vIGkxOG4KICNpbmNs dWRlIDxLTWVzc2FnZUJveD4KICNpbmNsdWRlIDxLVXJsUmVxdWVzdGVyPgorPj4+Pj4+PiAucjY5 MjM2NgoKICNpbmNsdWRlICJjc3ZleHBvcnRkaWFsb2cuaCIKICNpbmNsdWRlICJkZXNrdG9wdHJh Y2tlci5oIgogI2luY2x1ZGUgImVkaXR0YXNrZGlhbG9nLmgiCiAjaW5jbHVkZSAiaWRsZXRpbWVk ZXRlY3Rvci5oIgorPDw8PDw8PCAubWluZQorI2luY2x1ZGUgImZvY3VzZGV0ZWN0b3IuaCIKKyNp bmNsdWRlICJrYXJtc3RvcmFnZS5oIgorPT09PT09PQorPj4+Pj4+PiAucjY5MjM2NgogI2luY2x1 ZGUgInBsYW5uZXJwYXJzZXIuaCIKICNpbmNsdWRlICJwcmVmZXJlbmNlcy5oIgogI2luY2x1ZGUg InByaW50ZGlhbG9nLmgiCkBAIC0xMTYsNiArMTMxLDcgQEAKICAgICAgICAgICAgdGhpcywgU0xP VChzbG90SXRlbURvdWJsZUNsaWNrZWQoUVRyZWVXaWRnZXRJdGVtKiwgaW50KSkgKTsKCiAgIFFT dHJpbmdMaXN0IGxhYmVsczsKKyAgUVN0cmluZyBuYW1ld2luZG93Zm9jdXM7CiAgIGxhYmVscyA8 PCBpMThuKCJUYXNrIE5hbWUiKSA8PCBpMThuKCJTZXNzaW9uIFRpbWUiKSA8PCBpMThuKCJUaW1l IikgPDwgaTE4bigiVG90YWwgU2Vzc2lvbiBUaW1lIikgPDwgaTE4bigiVG90YWwgVGltZSIpIDw8 IGkxOG4oIlBlcmNlbnQgQ29tcGxldGUiKSA7CiAgIHNldEhlYWRlckxhYmVscyhsYWJlbHMpOwog ICBoZWFkZXJJdGVtKCktPnNldFdoYXRzVGhpcygwLCJUaGUgdGFzayBuYW1lIGlzIGhvdyB5b3Ug Y2FsbCB0aGUgdGFzaywgaXQgY2FuIGJlIGNob3NlIGZyZWVseS4iKTsKQEAgLTE0MCwyMyArMTU2 LDIyIEBACgogICAvLyBTZXQgdXAgdGhlIGlkbGUgZGV0ZWN0aW9uLgogICBfaWRsZVRpbWVEZXRl Y3RvciA9IG5ldyBJZGxlVGltZURldGVjdG9yKCBfcHJlZmVyZW5jZXMtPmlkbGVuZXNzVGltZW91 dCgpICk7Ci0gIGNvbm5lY3QoIF9pZGxlVGltZURldGVjdG9yLCBTSUdOQUwoIGV4dHJhY3RUaW1l KGludCkgKSwKLSAgICAgICAgICAgdGhpcywgU0xPVCggZXh0cmFjdFRpbWUoaW50KSApKTsKLSAg Y29ubmVjdCggX2lkbGVUaW1lRGV0ZWN0b3IsIFNJR05BTCggc3RvcEFsbFRpbWVycyhRRGF0ZVRp bWUpICksCi0gICAgICAgICAgIHRoaXMsIFNMT1QoIHN0b3BBbGxUaW1lcnMoUURhdGVUaW1lKSAp KTsKLSAgY29ubmVjdCggX3ByZWZlcmVuY2VzLCBTSUdOQUwoIGlkbGVuZXNzVGltZW91dChpbnQp ICksCi0gICAgICAgICAgIF9pZGxlVGltZURldGVjdG9yLCBTTE9UKCBzZXRNYXhJZGxlKGludCkg KSk7Ci0gIGNvbm5lY3QoIF9wcmVmZXJlbmNlcywgU0lHTkFMKCBkZXRlY3RJZGxlbmVzcyhib29s KSApLAotICAgICAgICAgICBfaWRsZVRpbWVEZXRlY3RvciwgU0xPVCggdG9nZ2xlT3ZlckFsbElk bGVEZXRlY3Rpb24oYm9vbCkgKSk7Ci0gIGlmICghX2lkbGVUaW1lRGV0ZWN0b3ItPmlzSWRsZURl dGVjdGlvblBvc3NpYmxlKCkpCi0gICAgX3ByZWZlcmVuY2VzLT5kaXNhYmxlSWRsZURldGVjdGlv bigpOworICBjb25uZWN0KCBfaWRsZVRpbWVEZXRlY3RvciwgU0lHTkFMKCBleHRyYWN0VGltZShp bnQpICksIHRoaXMsIFNMT1QoIGV4dHJhY3RUaW1lKGludCkgKSk7CisgIGNvbm5lY3QoIF9pZGxl VGltZURldGVjdG9yLCBTSUdOQUwoIHN0b3BBbGxUaW1lcnMoUURhdGVUaW1lKSApLCB0aGlzLCBT TE9UKCBzdG9wQWxsVGltZXJzKFFEYXRlVGltZSkgKSk7CisgIGNvbm5lY3QoIF9wcmVmZXJlbmNl cywgU0lHTkFMKCBpZGxlbmVzc1RpbWVvdXQoaW50KSApLCBfaWRsZVRpbWVEZXRlY3RvciwgU0xP VCggc2V0TWF4SWRsZShpbnQpICkpOworICBjb25uZWN0KCBfcHJlZmVyZW5jZXMsIFNJR05BTCgg ZGV0ZWN0SWRsZW5lc3MoYm9vbCkgKSwgX2lkbGVUaW1lRGV0ZWN0b3IsIFNMT1QoIHRvZ2dsZU92 ZXJBbGxJZGxlRGV0ZWN0aW9uKGJvb2wpICkpOwoKKyAgaWYgKCFfaWRsZVRpbWVEZXRlY3Rvci0+ aXNJZGxlRGV0ZWN0aW9uUG9zc2libGUoKSkgX3ByZWZlcmVuY2VzLT5kaXNhYmxlSWRsZURldGVj dGlvbigpOworCisvLyBTZXQgdXAgdGhlIGZvY3VzIGRldGVjdGlvbi4KKyAgX2ZvY3VzRGV0ZWN0 b3IgPSBuZXcgRm9jdXNEZXRlY3RvcigzMCk7CisgIGNvbm5lY3QoIF9mb2N1c0RldGVjdG9yLCBT SUdOQUwoIG5ld0ZvY3VzKFFTdHJpbmcpICksIHRoaXMsIFNMT1QoIG5ld0ZvY3VzV2luZG93RGV0 ZWN0ZWQgKFFTdHJpbmcpICkpOworCiAgIC8vIFNldHVwIGF1dG8gc2F2ZSB0aW1lcgogICBfYXV0 b1NhdmVUaW1lciA9IG5ldyBRVGltZXIodGhpcyk7CiAgIGNvbm5lY3QoIF9wcmVmZXJlbmNlcywg U0lHTkFMKCBhdXRvU2F2ZShib29sKSApLAogICAgICAgICAgICB0aGlzLCBTTE9UKCBhdXRvU2F2 ZUNoYW5nZWQoYm9vbCkgKSk7Ci0gIGNvbm5lY3QoIF9wcmVmZXJlbmNlcywgU0lHTkFMKCBhdXRv U2F2ZVBlcmlvZChpbnQpICksCi0gICAgICAgICAgIHRoaXMsIFNMT1QoIGF1dG9TYXZlUGVyaW9k Q2hhbmdlZChpbnQpICkpOworICBjb25uZWN0KCBfcHJlZmVyZW5jZXMsIFNJR05BTCggYXV0b1Nh dmVQZXJpb2QoaW50KSApLHRoaXMsIFNMT1QoIGF1dG9TYXZlUGVyaW9kQ2hhbmdlZChpbnQpICkp OwogICBjb25uZWN0KCBfYXV0b1NhdmVUaW1lciwgU0lHTkFMKCB0aW1lb3V0KCkgKSwgdGhpcywg U0xPVCggc2F2ZSgpICkpOwoKICAgLy8gU2V0dXAgbWFudWFsIHNhdmUgdGltZXIgKHRvIHNhdmUg Y2hhbmdlcyBhIGxpdHRsZSB3aGlsZSBhZnRlciB0aGV5IGhhcHBlbikKQEAgLTUzNiw3ICs1NTEs MTQgQEAKCiB2b2lkIFRhc2tWaWV3OjpzdGFydFRpbWVyRm9yKFRhc2sqIHRhc2ssIFFEYXRlVGlt ZSBzdGFydFRpbWUgKQogeworPDw8PDw8PCAubWluZQorIGtEZWJ1Zyg1OTcwKSA8PCAiRW50ZXJp bmcgVGFza1ZpZXc6OnN0YXJ0VGltZXJGb3IiIDw8IGVuZGw7CisKKyAgIF9mb2N1c0RldGVjdG9y LT5zdGFydEZvY3VzRGV0ZWN0aW9uKCk7CisgaWYgKHRhc2sgIT0gMCAmJiBhY3RpdmVUYXNrcy5m aW5kUmVmKHRhc2spID09IC0xKQorPT09PT09PQogICBpZiAodGFzayAhPSAwICYmIGFjdGl2ZVRh c2tzLmluZGV4T2YodGFzaykgPT0gLTEpCis+Pj4+Pj4+IC5yNjkyMzY2CiAgIHsKICAgICBpZiAo X3ByZWZlcmVuY2VzLT51bmlUYXNraW5nKCkpIHN0b3BBbGxUaW1lcnMoKTsKICAgICBfaWRsZVRp bWVEZXRlY3Rvci0+c3RhcnRJZGxlRGV0ZWN0aW9uKCk7CkBAIC01NTIsNyArNTc0LDExIEBACgog dm9pZCBUYXNrVmlldzo6Y2xlYXJBY3RpdmVUYXNrcygpCiB7Cisga0RlYnVnKDU5NzApIDw8ICJF bnRlcmluZyBUYXNrVmlldzo6Y2xlYXJBY3RpdmVUYXNrcyIgPDwgZW5kbDsKICAgYWN0aXZlVGFz a3MuY2xlYXIoKTsKKyAgX2ZvY3VzRGV0ZWN0b3ItPnN0YXJ0Rm9jdXNEZXRlY3Rpb24oKTsKKwor CiB9Cgogdm9pZCBUYXNrVmlldzo6c3RvcEFsbFRpbWVycyggUURhdGVUaW1lIHdoZW4gKQpAQCAt NTYyLDYgKzU4OCw3IEBACiAgICAgYWN0aXZlVGFza3MuYXQoaSktPnNldFJ1bm5pbmcoZmFsc2Us IF9zdG9yYWdlLCB3aGVuKTsKCiAgIF9pZGxlVGltZURldGVjdG9yLT5zdG9wSWRsZURldGVjdGlv bigpOworICBfZm9jdXNEZXRlY3Rvci0+c3RvcEZvY3VzRGV0ZWN0aW9uKCk7CiAgIGFjdGl2ZVRh c2tzLmNsZWFyKCk7CiAgIGVtaXQgdXBkYXRlQnV0dG9ucygpOwogICBlbWl0IHRpbWVyc0luYWN0 aXZlKCk7CkBAIC02NTUsNiArNjgyLDggQEAKICAgICAgIGRlc2t0b3BMaXN0LmNsZWFyKCk7Cgog ICAgIFFTdHJpbmcgdWlkID0gYWRkVGFzayggdGFza05hbWUsIHRvdGFsLCBzZXNzaW9uLCBkZXNr dG9wTGlzdCwgcGFyZW50ICk7CisgICAgIC8va0RlYnVnKDU5NzApIDw8ICJhZGRUYXNrIHRhc2tu YW1lID0gIiA8PCB0YXNrTmFtZSA8PCAidG90YWw6IiA8PCB0b3RhbCA8PCAidG90YWxkaWY6IiA8 PCB0b3RhbERpZmYgPDwgInNlc2lvbjoiIDw8IHNlc3Npb24gPDwgInNlc2lvbmRpZjoiIDw8IHNl c3Npb25EaWZmIDw8ICJkZXNrdG9wTGlzdCIgPDwgZGVza3RvcExpc3QgPDwgIGVuZGw7CisKICAg ICBpZiAoIHVpZC5pc051bGwoKSApCiAgICAgewogICAgICAgS01lc3NhZ2VCb3g6OmVycm9yKCAw LCBpMThuKApAQCAtODYxLDYgKzg5MCw1OSBAQAogICBhdXRvU2F2ZUNoYW5nZWQoX3ByZWZlcmVu Y2VzLT5hdXRvU2F2ZSgpKTsKIH0KCit2b2lkIFRhc2tWaWV3OjpuZXdGb2N1c1dpbmRvd0RldGVj dGVkKGNvbnN0IFFTdHJpbmcgdGFza05hbWUpCit7CisgIGNvbnN0IERlc2t0b3BMaXN0IGRlc2t0 b3BMaXN0OworICBUYXNrKiB0YXNrPTA7CisgIFFTdHJpbmcgcnZhbD0iIjsKKyAgUVN0cmluZyB0 YXNrdWlkOworICBzdG9wVGltZXJGb3IobGFzdFRhc2tXaXRoRm9jdXMpOworICBpbnQgaT0wOwor ICBmb3IgKCBUYXNrKiB0YXNrMyA9IGl0ZW1fYXRfaW5kZXgoaSk7IHRhc2szOyB0YXNrMyA9IGl0 ZW1fYXRfaW5kZXgoKytpKSApCisgICAgICB7CisgICAgICAgICAvL2tEZWJ1Zyg1OTcwKSA8PCAi c2VlbiB0aGlzIHRhc2sgPSAtIiAgPDwgdGFzazMtPm5hbWUoKSA8PCAiLSIgPDwgdGFza05hbWUg PDwgIi0iPDwgZW5kbDsKKyAgICAgICAgIGlmICh0YXNrMy0+bmFtZSgpPT10YXNrTmFtZSkKKyAg ICAgICAgICB7CisgICAgICAgICAgICAgcnZhbD0iaW5zaWRlIjsKKyAgICAgICAgICAgICAvL2tE ZWJ1Zyg1OTcwKSA8PCAidGhpcyB0YXNrIGhhcyBzYW1lIGNvZGVuYW1lICIgIDw8IHRhc2tOYW1l IDw8ICIgIiA8PCB0YXNrMy0+bmFtZSgpIDw8IGVuZGw7CisgICAgICAgICAgICAgc3RhcnRUaW1l ckZvcih0YXNrMyk7CisgICAgICAgICAgICAgbGFzdFRhc2tXaXRoRm9jdXM9dGFzazM7CisgICAg ICAgICAgfQorICAgICAgfQorICBpZiAgKHJ2YWw9PSIiKQorICAgICAgeworICAgICAgICAvL2tE ZWJ1Zyg1OTcwKSA8PCAidGhlcmUgaXMgbm90IHRhc2sgd2l0aCB0aGF0IGNvZGVuYW1lICIgPDwg dGFza05hbWUgIDw8IGVuZGw7CisgICAgICAgICB0YXNrdWlkPSBhZGRUYXNrKHRhc2tOYW1lLCAw TCwgMEwsIGRlc2t0b3BMaXN0LCAgdGFzayApOworICAgICAgIGlmICggdGFza3VpZC5pc051bGwo KSApCisgICAgICAgICAgeworICAgICAgICAgICAgICAgICAgIEtNZXNzYWdlQm94OjplcnJvcigg MCwgaTE4bigKKyAgICAgICAgICAgIkVycm9yIHN0b3JpbmcgbmV3IHRhc2suIFlvdXIgY2hhbmdl cyB3ZXJlIG5vdCBzYXZlZC4gTWFrZSBzdXJlIHlvdSBjYW4gZWRpdCB5b3VyIGlDYWxlbmRhciBm aWxlLiBBbHNvIHF1aXQgYWxsIGFwcGxpY2F0aW9ucyB1c2luZyB0aGlzIGZpbGUgYW5kIHJlbW92 ZSBhbnkgbG9jayBmaWxlIHJlbGF0ZWQgdG8gaXRzIG5hbWUgZnJvbSB+Ly5rZGUvc2hhcmUvYXBw cy9rYWJjL2xvY2svICIgKSApOworICAgICAgICAgICB9CisgICAgICAgIGk9MDsKKyAgICAgICAg Zm9yICggVGFzayogdGFzazMgPSBpdGVtX2F0X2luZGV4KGkpOyB0YXNrMzsgdGFzazMgPSBpdGVt X2F0X2luZGV4KCsraSkgKQorICAgICAgICAgIHsKKyAgICAgICAgICAgICAvL2tEZWJ1Zyg1OTcw KSA8PCAic2VlbiB0aGlzIHRhc2sgKG5vdCBoZXJlKSAtIiAgPDwgdGFzazMtPm5hbWUoKSA8PCAi LSIgPDwgdGFza05hbWUgPDwgIi0iPDwgZW5kbDsKKworICAgICAgICAgICAgIGlmICh0YXNrMy0+ bmFtZSgpPT10YXNrTmFtZSkKKyAgICAgICAgICAgICAgeworICAgICAgICAgICAgICAgICBydmFs PSJpbnNpZGUiOworICAgICAgICAgICAgICAgICAvL2tEZWJ1Zyg1OTcwKSA8PCAidGhlIHRhc2sg aXMgaGVyZSA9ICIgIDw8IHRhc2tOYW1lIDw8ICIgIiA8PCB0YXNrMy0+bmFtZSgpIDw8IGVuZGw7 CisgICAgICAgICAgICAgICAgIHN0YXJ0VGltZXJGb3IodGFzazMpOworICAgICAgICAgICAgICAg ICBsYXN0VGFza1dpdGhGb2N1cz10YXNrMzsKKyAgICAgICAgICAgICAgfQorICAgICAgICAgfQor ICAgICAgIH0KKyAgaT0wOworICAvL2tEZWJ1Zyg1OTcwKSA8PCAibGlzdCBvZiB0YXNrcyAtIiAg PDwgdGFzazMtPm5hbWUoKSA8PCAiLSIgPDwgdGFza05hbWUgPDwgIi0iPDwgZW5kbDsKKyAgLy9m b3IgKCBUYXNrKiB0YXNrMyA9IGl0ZW1fYXRfaW5kZXgoaSk7IHRhc2szOyB0YXNrMyA9IGl0ZW1f YXRfaW5kZXgoKytpKSApCisgIC8vICAgIHsKKyAgLy8gICAgICAga0RlYnVnKDU5NzApIDw8ICJ0 YXNrOiAtIiAgPDwgdGFzazMtPm5hbWUoKSA8PCAiLSIgPDwgdGFza05hbWUgPDwgIi0iPDwgZW5k bDsKKyAgLy8gICAgfQorICBlbWl0IHVwZGF0ZUJ1dHRvbnMoKTsKK30KKworCisKIHZvaWQgVGFz a1ZpZXc6OmFkYXB0Q29sdW1ucygpCiAvKiBUaGlzIHByb2NlZHVyZSBhZGFwdHMgdGhlIGNvbHVt bnMsIGl0IGNhbiBlLmcuIGJlIGNhbGxlZCB3aGVuIHRoZSB1c2VyCiBjaGFuZ2VzIHRoZSB0aW1l IGZvcm1hdCBvciByZXF1ZXN0cyB0byBoaWRlIHNvbWUgY29sdW1ucy4KSW5kZXg6IGZvY3VzZGV0 ZWN0b3IuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIGZvY3VzZGV0ZWN0b3IuY3BwICAgKHJldmlzacOzbjog MCkKKysrIGZvY3VzZGV0ZWN0b3IuY3BwICAgKHJldmlzacOzbjogMCkKQEAgLTAsMCArMSw5NCBA QAorLyoKKyAqICAgICBDb3B5cmlnaHQgKEMpIDIwMDcgdGhlIGt0aW1ldHJhY2tlciBkZXZlbG9w ZXJzCisgKgorICogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICogICB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBv cgorICogICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICAgVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisgKiAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nCisgKiAgIHdpdGgg dGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZQorICogICAgICBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4KKyAqICAgICAgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9v cgorICogICAgICBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EuCisgKgorICogQHNob3J0IExv Z2ljIHRoYXQgZ2V0cyBhbmQgc3RvcmVzIHRhc2tzIGZyb20gZm9jdXNlZCB3aW5kb3dzLgorICog QGF1dGhvciBSZW7DqSBNw6lyb3UgPG9jaG9taW51dG9zZGVhcmNvQGdtYWlsLmNvbT4KKyAqLwor I2luY2x1ZGUgPFFQcm9jZXNzPgorI2luY2x1ZGUgImZvY3VzZGV0ZWN0b3IuaCIKKworI2luY2x1 ZGUgPHFkYXRldGltZS5oPgorI2luY2x1ZGUgPHFtZXNzYWdlYm94Lmg+CisjaW5jbHVkZSA8cXRp bWVyLmg+CisKKyNpbmNsdWRlIDxrZGlhbG9nLmg+CisjaW5jbHVkZSA8a2dsb2JhbC5oPgorI2lu Y2x1ZGUgPGtsb2NhbGUuaD4gICAgLy8gaTE4bgorI2luY2x1ZGUgPFFMYWJlbD4KKyNpbmNsdWRl IDxRSEJveExheW91dD4KKyNpbmNsdWRlIDxRVkJveExheW91dD4KKyNpZmRlZiBRX1dTX1gxMQor I2luY2x1ZGUgPFFYMTFJbmZvPgorI2VuZGlmCisgIFFTdHJpbmcgbGFzdFdpbmRvdz0iIjsKK0Zv Y3VzRGV0ZWN0b3I6OkZvY3VzRGV0ZWN0b3IoaW50IHBlcmlvZEZvY3VzKQoreworICBfdGltZXIg PSBuZXcgUVRpbWVyKHRoaXMpOworICBjb25uZWN0KF90aW1lciwgU0lHTkFMKHRpbWVvdXQoKSks IHRoaXMsIFNMT1QoY2hlY2soKSkpOworICBfdGltZXItPnN0YXJ0KDEwMDAqcGVyaW9kRm9jdXMp OworfQorCit2b2lkIEZvY3VzRGV0ZWN0b3I6OmNoZWNrKCkKK3sKKyBRUHJvY2VzcyBmb2N1c1F1 ZXN0aW9uOworIFFTdHJpbmcgbWVuc2FqZT0ieHByb3AgLXJvb3QiOworIFFTdHJpbmcgdHJvem8x LHRyb3pvMix0cm96bzM7CisgUVN0cmluZyBjYWRlbmE9Il9ORVRfQUNUSVZFX1dJTkRPVyhXSU5E T1cpOiB3aW5kb3cgaWQgIyAiOworCisgZm9jdXNRdWVzdGlvbi5zZXRQcm9jZXNzQ2hhbm5lbE1v ZGUoUVByb2Nlc3M6Ok1lcmdlZENoYW5uZWxzKTsKKyBmb2N1c1F1ZXN0aW9uLnN0YXJ0KCBtZW5z YWplICk7CisKKyBpZiAoIWZvY3VzUXVlc3Rpb24ud2FpdEZvckZpbmlzaGVkKCkpCisgICAgIHFE ZWJ1ZygpIDw8ICJNYWtlIGZhaWxlZDoiIDw8IGZvY3VzUXVlc3Rpb24uZXJyb3JTdHJpbmcoKTsK KyBlbHNlCisgICAgIHRyb3pvMT1mb2N1c1F1ZXN0aW9uLnJlYWRBbGwoKTsKKyAgICAgdHJvem8z PXRyb3pvMS5taWQodHJvem8xLmxhc3RJbmRleE9mKGNhZGVuYSkrNDAsOSk7CisgICAgIHRyb3pv Mz0ieHdpbmluZm8gLWlkICIgKyB0cm96bzM7CisgICAgIGZvY3VzUXVlc3Rpb24uc3RhcnQodHJv em8zKTsKKyBpZiAoIWZvY3VzUXVlc3Rpb24ud2FpdEZvckZpbmlzaGVkKCkpCisgICAgIHFEZWJ1 ZygpIDw8ICJNYWtlIGZhaWxlZDoiIDw8IGZvY3VzUXVlc3Rpb24uZXJyb3JTdHJpbmcoKTsKKyBl bHNlCisgICAgIHRyb3pvMT1mb2N1c1F1ZXN0aW9uLnJlYWRBbGwoKTsKKyAgICAgdHJvem8yPXRy b3pvMS5taWQodHJvem8xLmxhc3RJbmRleE9mKCJXaW5kb3cgaWQiKSsyMiwyMDApOworICAgICB0 cm96bzM9dHJvem8yLmxlZnQoIHRyb3pvMi5pbmRleE9mKCJBYnNvbHV0ZSB1cHBlci1sZWZ0IFgi KS01KTsKKyAgICAgaWYgKGxhc3RXaW5kb3chPXRyb3pvMykgeworICAgICAgICBsYXN0V2luZG93 PXRyb3pvMzsKKyAgICAgICBxRGVidWcoKSA8PCAiTkVXIFdJTkRPVyBXSVRIIEZPQ1VTOyBTZW5k aW5nIHNpZ25hbDoiIDw8IHRyb3pvMyA8PCBlbmRsOworICAgICAgICBlbWl0IChuZXdGb2N1cyh0 cm96bzMpKTsKKyAgICAgfQorfQorCit2b2lkIEZvY3VzRGV0ZWN0b3I6OnNldFBlcmlvZEZvY3Vz KGludCBwZXJpb2RGb2N1cykKK3sKKyAgX3BlcmlvZEZvY3VzID0gcGVyaW9kRm9jdXM7Cit9CisK K3ZvaWQgRm9jdXNEZXRlY3Rvcjo6c3RhcnRGb2N1c0RldGVjdGlvbigpCit7CisgIGlmICghX3Rp bWVyLT5pc0FjdGl2ZSgpKQorICAgIF90aW1lci0+c3RhcnQocGVyaW9kSW50ZXJ2YWwpOworfQor Cit2b2lkIEZvY3VzRGV0ZWN0b3I6OnN0b3BGb2N1c0RldGVjdGlvbigpCit7CisgIGlmIChfdGlt ZXItPmlzQWN0aXZlKCkpCisgICAgX3RpbWVyLT5zdG9wKCk7Cit9CisKKyNpbmNsdWRlICJmb2N1 c2RldGVjdG9yLm1vYyIKSW5kZXg6IG1haW53aW5kb3cuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIG1haW53 aW5kb3cuY3BwICAgICAgKHJldmlzacOzbjogNjkyMzY2KQorKysgbWFpbndpbmRvdy5jcHAgICAg ICAoY29waWEgZGUgdHJhYmFqbykKQEAgLTE1OSw3ICsxNTksMjAgQEAKICAgc2F2ZUdlb21ldHJ5 KCk7CiAgIHJldHVybiB0cnVlOwogfQordm9pZCBNYWluV2luZG93Ojp0b3BXaW5kb3dUcmFja2Vy KCkKK3sKKyAgaW50IGE9MDsKKyAga0RlYnVnKDU5NzApIDw8ICJlbnRybyBlbiB0b3BXaW5kb3dU cmFja2VyLiIgPDwgZW5kbDsKKyAgLy9zdGF0dXNCYXIoKS0+c2hvd01lc3NhZ2UoaTE4bigicGFz ZSBwb3IgYXF1aSIpLDE4MDcpOworICBzdGF0dXNCYXIoKS0+c2hvd01lc3NhZ2UoaTE4bigiU3Vj Y2Vzc2Z1bGx5eSBzYXZlZCB0YXNrcyBhbmQgaGlzdG9yeSIpLDE4MDcpOworICB3aGlsZSAoYTwx MDAwKXsKKyAgICAgICBhPWErMTsKKyAgICAgICBzdGF0dXNCYXIoKS0+c2hvd01lc3NhZ2UoaTE4 bigiU3VjY2Vzc2Z1bGx5eXl5IHNhdmVkIHRhc2tzIGFuZCBoaXN0b3J5IiksMTgwNyk7CisgICAg ICAgLy9zdGF0dXNCYXIoKS0+c2hvd01lc3NhZ2UoaTE4bigicGFzZSBwb3IgYXF1aSAlaSIpLDE4 MDcsYSk7CisgIH0KK30KCisKIHZvaWQgTWFpbldpbmRvdzo6ZXhwb3J0Y3N2SGlzdG9yeSgpCiB7 CiAgIGtEZWJ1Zyg1OTcwKSA8PCAiRXhwb3J0aW5nIEhpc3RvcnkgdG8gZGlzay4iIDw8IGVuZGw7 CkluZGV4OiBpZGxldGltZWRldGVjdG9yLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gaWRsZXRpbWVkZXRlY3Rv ci5oICAocmV2aXNpw7NuOiA2OTIzNjYpCisrKyBpZGxldGltZWRldGVjdG9yLmggIChjb3BpYSBk ZSB0cmFiYWpvKQpAQCAtMTksOCArMTksOCBAQAogICoKICAqLwoKLSNpZm5kZWYgS0FSTV9JRExF X1RJTUVfREVURUNUT1JfSAotI2RlZmluZSBLQVJNX0lETEVfVElNRV9ERVRFQ1RPUl9ICisjaWZu ZGVmIEtBUk1fRk9DVVNfREVURUNUT1JfSAorI2RlZmluZSBLQVJNX0ZPQ1VTX0RFVEVDVE9SX0gK CiAjaW5jbHVkZSA8UURhdGVUaW1lPgogI2luY2x1ZGUgPFFPYmplY3Q+CkBAIC0xMTIsNiArMTEy LDkgQEAKIHByb3RlY3RlZCBRX1NMT1RTOgogICB2b2lkIGNoZWNrKCk7CgorICBzaWduYWxzOgor ICB2b2lkIGZvY3VzQ2hhbmdlZCgpOworCiBwcml2YXRlOgogI2lmIGRlZmluZWQoSEFWRV9MSUJY U1MpICYmIGRlZmluZWQoUV9XU19YMTEpCiAgIFhTY3JlZW5TYXZlckluZm8gKl9taXRfaW5mbzsK SW5kZXg6IG1haW53aW5kb3cuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBtYWlud2luZG93LmggICAgICAgIChy ZXZpc2nDs246IDY5MjM2NikKKysrIG1haW53aW5kb3cuaCAgICAgICAgKGNvcGlhIGRlIHRyYWJh am8pCkBAIC0xMDIsNiArMTAyLDggQEAKICAgICBRU3RyaW5nIHNldHByb21wdGRlbGV0ZSggYm9v bCBwcm9tcHQgKTsKICAgICBRU3RyaW5nIGV4cG9ydGNzdmZpbGUoIFFTdHJpbmcgZmlsZW5hbWUs IFFTdHJpbmcgZnJvbSwgUVN0cmluZyB0bywgaW50IHR5cGUsIGJvb2wgZGVjaW1hbE1pbnV0ZXMs IGJvb2wgYWxsVGFza3MsIFFTdHJpbmcgZGVsaW1pdGVyLCBRU3RyaW5nIHF1b3RlICk7CiAgICAg UVN0cmluZyBpbXBvcnRwbGFubmVyZmlsZSggUVN0cmluZyBmaWxlbmFtZSApOworICAgIC8qKiB0 ZXN0IHRvcHdpbmRvd3RyYWNrZXIgKi8KKyAgICB2b2lkIHRvcFdpbmRvd1RyYWNrZXIoKTsKCiAg IHB1YmxpYyBRX1NMT1RTOgogICAgIHZvaWQgc2V0U3RhdHVzQmFyKCBjb25zdCBRU3RyaW5nJiAp OwpAQCAtMTA5LDcgKzExMSwxMyBAQAogICAgIHZvaWQgcXVpdCgpOwogICAgIC8qKiBTYXZlIHRo ZSBjYWxlbmRhciAqLwogICAgIGJvb2wgc2F2ZSgpOworPDw8PDw8PCAubWluZQorCisKKyAgcHJv dGVjdGVkIHNsb3RzOgorPT09PT09PQogICBwcm90ZWN0ZWQgUV9TTE9UUzoKKz4+Pj4+Pj4gLnI2 OTIzNjYKICAgICB2b2lkIGtleUJpbmRpbmdzKCk7CiAgICAgdm9pZCBzdGFydE5ld1Nlc3Npb24o KTsKICAgICB2b2lkIHJlc2V0QWxsVGltZXMoKTsKSW5kZXg6IG1haW4uY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIG1haW4uY3BwICAgIChyZXZpc2nDs246IDY5MjM2NikKKysrIG1haW4uY3BwICAgIChjb3Bp YSBkZSB0cmFiYWpvKQpAQCAtNTYsNiArNTYsNyBAQAogICBhYm91dERhdGEuYWRkQXV0aG9yKCBr aTE4bigiSmVzcGVyIFBlZGVyc2VuIiksICAgS0xvY2FsaXplZFN0cmluZygpLCAiYmxhY2tpZUBr ZGUub3JnIiApOwogICBhYm91dERhdGEuYWRkQXV0aG9yKCBraTE4bigiS2FsbGUgRGFsaGVpbWVy IiksICAgS0xvY2FsaXplZFN0cmluZygpLCAia2FsbGVAa2RlLm9yZyIgKTsKICAgYWJvdXREYXRh LmFkZEF1dGhvcigga2kxOG4oIk1hcmsgQnVjY2lhcmVsbGkiKSwgIEtMb2NhbGl6ZWRTdHJpbmco KSwgIm1hcmtAaHViY2FwY29uc3VsdGluZy5jb20iICk7CisgIGFib3V0RGF0YS5hZGRBdXRob3Io IGtpMThuKCJSZW7DqSBNw6lyb3UiKSwgICAgICAgIEtMb2NhbGl6ZWRTdHJpbmcoKSwgIm9jaG9t aW51dG9zZGVhcmNvQGdtYWlsLmNvbSIgKTsKCiAgIEtDbWRMaW5lQXJnczo6aW5pdCggYXJnYywg YXJndiwgJmFib3V0RGF0YSApOwoKSW5kZXg6IENNYWtlTGlzdHMudHh0Cj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IENNYWtlTGlzdHMudHh0ICAgICAgKHJldmlzacOzbjogNjkyMzY2KQorKysgQ01ha2VMaXN0cy50 eHQgICAgICAoY29waWEgZGUgdHJhYmFqbykKQEAgLTEzLDcgKzEzLDcgQEAKICMjIyMjIyMjIyMj IG5leHQgdGFyZ2V0ICMjIyMjIyMjIyMjIyMjIwogc2V0KGthcm1fc2hhcmVkX1NSQ1MKICAgICAg ICBrYWNjZWxtZW51d2F0Y2guY3BwIGRlc2t0b3B0cmFja2VyLmNwcAotICAgICAgIGVkaXR0YXNr ZGlhbG9nLmNwcCBpZGxldGltZWRldGVjdG9yLmNwcAorICAgICAgIGVkaXR0YXNrZGlhbG9nLmNw cCBpZGxldGltZWRldGVjdG9yLmNwcCBmb2N1c2RldGVjdG9yLmNwcAogICAgICAgIHByaW50ZGlh bG9nLmNwcCB0aW1la2FyZC5jcHAga2FybXV0aWxpdHkuY3BwIGt0aW1ld2lkZ2V0LmNwcAogICAg ICAgIGthcm1zdG9yYWdlLmNwcCBtYWlud2luZG93LmNwcCBwcmVmZXJlbmNlcy5jcHAgcHJpbnQu Y3BwCiAgICAgICAgdGFzay5jcHAgdGFza3ZpZXcuY3BwIHRyYXkuY3BwCg== 21258 2007-07-27 06:19:39 +0000 2007-07-27 07:04:45 +0000 please base your development on this patch from now on ktimetrackerpatch.diff text/plain 5496 dev SW5kZXg6IHRhc2t2aWV3LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gdGFza3ZpZXcuaAkocmV2aXNpb24gNjkz MDAzKQorKysgdGFza3ZpZXcuaAkod29ya2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2lu Y2x1ZGUgImRlc2t0b3BsaXN0LmgiCiAjaW5jbHVkZSAia2FybXN0b3JhZ2UuaCIKICNpbmNsdWRl ICJyZXBvcnRjcml0ZXJpYS5oIgorI2luY2x1ZGUgImZvY3VzZGV0ZWN0b3IuaCIKIAogY2xhc3Mg UU1vdXNlRXZlbnQ7CiBjbGFzcyBRU3RyaW5nOwpAQCAtMTM3LDcgKzEzOCwxMyBAQAogCiAgICAg LyoqIENhbGxzIG5ld1Rhc2sgZGlhbG9nIHdpdGggY2FwdGlvbiAiTmV3IFN1YiBUYXNrIi4gKi8K ICAgICB2b2lkIG5ld1N1YlRhc2soKTsKLQorICAgIC8qKiBzdGFydCB0aGUgYXV0b3RyYWNraW5n IHN5c3RlbSB0byBhZGQgdGFza3MgdG8gY29udHJvbCB0aW1lIGZvciBldmVyeQorZm9jdXNlZCB3 aW5kb3dzICoqLworICAgIHZvaWQgc3RhcnRBdXRvVHJhY2tpbmcoKXt9OworICAgIC8qKiBzdG9w IHRoZSBhdXRvdHJhY2tpbmcgc3lzdGVtIHRvIGFkZCB0YXNrcyB0byBjb250cm9sIHRpbWUgZm9y IGV2ZXJ5Citmb2N1c2VkIHdpbmRvd3MgKiovICAgIAordm9pZCBzdG9wQXV0b1RyYWNraW5nKCl7 fTsKKyAKICAgICB2b2lkIGVkaXRUYXNrKCk7CiAKICAgICAvKioKQEAgLTIwOCw3ICsyMTUsOCBA QAogICAgIHZvaWQgc2V0U3RhdHVzQmFyVGV4dChRU3RyaW5nKTsKIAogICBwcml2YXRlOiAvLyBt ZW1iZXIgdmFyaWFibGVzCi0gICAgSWRsZVRpbWVEZXRlY3RvciAqX2lkbGVUaW1lRGV0ZWN0b3I7 CisgICAgSWRsZVRpbWVEZXRlY3RvciogX2lkbGVUaW1lRGV0ZWN0b3I7CisgICAgRm9jdXNEZXRl Y3RvciogX2ZvY3VzRGV0ZWN0b3I7CiAgICAgUVRpbWVyICpfbWludXRlVGltZXI7CiAgICAgUVRp bWVyICpfYXV0b1NhdmVUaW1lcjsKICAgICBRVGltZXIgKl9tYW51YWxTYXZlVGltZXI7CkBAIC0y MTgsNiArMjI2LDcgQEAKICAgICBib29sIF9pc2xvYWRpbmc7CiAgICAgVGFzayogZHJhZ1Rhc2s7 CiAgICAgUVRhYmxlV2lkZ2V0KiBoaXN0b3J5d2lkZ2V0OworICAgIFRhc2sqICBsYXN0VGFza1dp dGhGb2N1czsKIAogICAgIC8vS0NhbDo6Q2FsZW5kYXJMb2NhbCBfY2FsZW5kYXI7CiAgICAgS2Fy bVN0b3JhZ2UgKiBfc3RvcmFnZTsKQEAgLTI0NSw2ICsyNTQsOCBAQAogICAgICAgIFRoaXMgaXMg bm90IGlDYWxGaWxlQ2hhbmdlZC4gKi8KICAgICB2b2lkIGlDYWxGaWxlTW9kaWZpZWQoUmVzb3Vy Y2VDYWxlbmRhciAqKTsKICAgICB2b2lkIHNsb3RJdGVtRG91YmxlQ2xpY2tlZCggUVRyZWVXaWRn ZXRJdGVtICppdGVtLCBpbnQgKTsKKyAgICB2b2lkIG5ld0ZvY3VzV2luZG93RGV0ZWN0ZWQgKFFT dHJpbmcpOworCiAgICAgdm9pZCBzbG90Q29sdW1uVG9nZ2xlZCggaW50ICk7CiB9OwogCkluZGV4 OiB0YXNrdmlldy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gdGFza3ZpZXcuY3BwCShyZXZpc2lvbiA2OTMw MDMpCisrKyB0YXNrdmlldy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEwNyw2ICsxMDcsNyBAQAog ewogICBfcHJlZmVyZW5jZXMgPSBQcmVmZXJlbmNlczo6aW5zdGFuY2UoIGljc2ZpbGUgKTsKICAg X3N0b3JhZ2UgPSBLYXJtU3RvcmFnZTo6aW5zdGFuY2UoKTsKKyAgX2ZvY3VzRGV0ZWN0b3IgPSBu ZXcgRm9jdXNEZXRlY3RvcigxKTsKIAogICBjb25uZWN0KCB0aGlzLCBTSUdOQUwoaXRlbUV4cGFu ZGVkKFFUcmVlV2lkZ2V0SXRlbSopKSwKICAgICAgICAgICAgdGhpcywgU0xPVChpdGVtU3RhdGVD aGFuZ2VkKFFUcmVlV2lkZ2V0SXRlbSopKSApOwpAQCAtMTE0LDcgKzExNSw4IEBACiAgICAgICAg ICAgIHRoaXMsIFNMT1QoaXRlbVN0YXRlQ2hhbmdlZChRVHJlZVdpZGdldEl0ZW0qKSkgKTsKICAg Y29ubmVjdCggdGhpcywgU0lHTkFMKGl0ZW1Eb3VibGVDbGlja2VkKFFUcmVlV2lkZ2V0SXRlbSos IGludCkpLAogICAgICAgICAgICB0aGlzLCBTTE9UKHNsb3RJdGVtRG91YmxlQ2xpY2tlZChRVHJl ZVdpZGdldEl0ZW0qLCBpbnQpKSApOwotCisgIGNvbm5lY3QoIF9mb2N1c0RldGVjdG9yLCBTSUdO QUwoIG5ld0ZvY3VzKFFTdHJpbmcpICksIHRoaXMsIFNMT1QoCituZXdGb2N1c1dpbmRvd0RldGVj dGVkIChRU3RyaW5nKSApKTsgCiAgIFFTdHJpbmdMaXN0IGxhYmVsczsKICAgbGFiZWxzIDw8IGkx OG4oIlRhc2sgTmFtZSIpIDw8IGkxOG4oIlNlc3Npb24gVGltZSIpIDw8IGkxOG4oIlRpbWUiKSA8 PCBpMThuKCJUb3RhbCBTZXNzaW9uIFRpbWUiKSA8PCBpMThuKCJUb3RhbCBUaW1lIikgPDwgaTE4 bigiUGVyY2VudCBDb21wbGV0ZSIpIDsKICAgc2V0SGVhZGVyTGFiZWxzKGxhYmVscyk7CkBAIC0x NzksNiArMTgxLDYwIEBACiAgIGNvbm5lY3QoIGhlYWRlckNvbnRleHRNZW51LCBTSUdOQUwoY29s dW1uVG9nZ2xlZChpbnQpKSwgdGhpcywgU0xPVChzbG90Q29sdW1uVG9nZ2xlZChpbnQpKSApOwog fQogCit2b2lkIFRhc2tWaWV3OjpuZXdGb2N1c1dpbmRvd0RldGVjdGVkKGNvbnN0IFFTdHJpbmcg dGFza05hbWUpCit7CisgIGNvbnN0IERlc2t0b3BMaXN0IGRlc2t0b3BMaXN0OworICBUYXNrKiB0 YXNrPTA7CisgIFFTdHJpbmcgcnZhbD0iIjsKKyAgUVN0cmluZyB0YXNrdWlkOworICBzdG9wVGlt ZXJGb3IobGFzdFRhc2tXaXRoRm9jdXMpOworICBpbnQgaT0wOworICBmb3IgKCBUYXNrKiB0YXNr MyA9IGl0ZW1fYXRfaW5kZXgoaSk7IHRhc2szOyB0YXNrMyA9IGl0ZW1fYXRfaW5kZXgoKytpKSAp CisgICAgICB7CisgICAvL2tEZWJ1Zyg1OTcwKSA8PCAic2VlbiB0aGlzIHRhc2sgPSAtIiAgPDwg dGFzazMtPm5hbWUoKSA8PCAiLSIgPDwgdGFza05hbWUgPDwgIi0iPDwgZW5kbDsKKyAgIGlmICh0 YXNrMy0+bmFtZSgpPT10YXNrTmFtZSkKKyAgICB7CisgICAgICAgcnZhbD0iaW5zaWRlIjsKKyAg ICAgICAvL2tEZWJ1Zyg1OTcwKSA8PCAidGhpcyB0YXNrIGhhcyBzYW1lIGNvZGVuYW1lICIgPDwg dGFza05hbWUgPDwgIiAiIDw8IHRhc2szLT5uYW1lKCkgPDwgZW5kbDsKKyAgICAgICBzdGFydFRp bWVyRm9yKHRhc2szKTsKKyAgICAgICBsYXN0VGFza1dpdGhGb2N1cz10YXNrMzsKKyAgICB9Cisg ICAgICB9CisgIGlmICAocnZhbD09IiIpCisgICAgICB7CisgLy9rRGVidWcoNTk3MCkgPDwgInRo ZXJlIGlzIG5vdCB0YXNrIHdpdGggdGhhdCBjb2RlbmFtZSAiIDw8IHRhc2tOYW1lIDw8IGVuZGw7 CisgICB0YXNrdWlkPSBhZGRUYXNrKHRhc2tOYW1lLCAwTCwgMEwsIGRlc2t0b3BMaXN0LCAgdGFz ayApOworIGlmICggdGFza3VpZC5pc051bGwoKSApCisgICAgeworICAgICBLTWVzc2FnZUJveDo6 ZXJyb3IoIDAsIGkxOG4oCisgICAgICJFcnJvciBzdG9yaW5nIG5ldyB0YXNrLiBZb3VyIGNoYW5n ZXMgd2VyZSBub3Qgc2F2ZWQuIE1ha2Ugc3VyZSB5b3UgY2FuIGVkaXQgeW91ciBpQ2FsZW5kYXIg ZmlsZS4gQWxzbyBxdWl0IGFsbCBhcHBsaWNhdGlvbnMgdXNpbmcgdGhpcyBmaWxlIGFuZCByZW1v dmUgYW55IGxvY2sgZmlsZSByZWxhdGVkIHRvIGl0cyBuYW1lIGZyb20gfi8ua2RlL3NoYXJlL2Fw cHMva2FiYy9sb2NrLyAiICkKKyk7CisgICAgIH0KKyBpPTA7CisgZm9yICggVGFzayogdGFzazMg PSBpdGVtX2F0X2luZGV4KGkpOyB0YXNrMzsgdGFzazMgPQoraXRlbV9hdF9pbmRleCgrK2kpICkK KyAgICB7CisgICAgICAgLy9rRGVidWcoNTk3MCkgPDwgInNlZW4gdGhpcyB0YXNrIChub3QgaGVy ZSkgLSIgIDw8IHRhc2szLT5uYW1lKCkgPDwgIi0iIDw8IHRhc2tOYW1lIDw8ICItIjw8IGVuZGw7 CisKKyAgICAgICBpZiAodGFzazMtPm5hbWUoKT09dGFza05hbWUpCisgICAgICAgeworICAgcnZh bD0iaW5zaWRlIjsKKyAgIC8va0RlYnVnKDU5NzApIDw8ICJ0aGUgdGFzayBpcyBoZXJlID0gIiAg PDwgdGFza05hbWUgPDwgIiAiIDw8IHRhc2szLT5uYW1lKCkgPDwgZW5kbDsKKyAgIHN0YXJ0VGlt ZXJGb3IodGFzazMpOworICAgbGFzdFRhc2tXaXRoRm9jdXM9dGFzazM7CisgICAgICAgIH0KKyAg IH0KKyB9CisgIGk9MDsKKyAgLy9rRGVidWcoNTk3MCkgPDwgImxpc3Qgb2YgdGFza3MgLSIgPDwg dGFzazMtPm5hbWUoKSA8PCAiLSIgPDwgdGFza05hbWUgPDwgIi0iPDwgZW5kbDsKKyAgLy9mb3Ig KCBUYXNrKiB0YXNrMyA9IGl0ZW1fYXRfaW5kZXgoaSk7IHRhc2szOyB0YXNrMyA9IGl0ZW1fYXRf aW5kZXgoKytpKSApCisgIC8vIHsKKyAgLy8gICAgIGtEZWJ1Zyg1OTcwKSA8PCAidGFzazogLSIg IDw8IHRhc2szLT5uYW1lKCkgPDwgIi0iIDw8IHRhc2tOYW1lIDw8ICItIjw8IGVuZGw7CisgIC8v IH0KKyAgZW1pdCB1cGRhdGVCdXR0b25zKCk7Cit9IAorCisKIHZvaWQgVGFza1ZpZXc6OmRyb3BF dmVudChRRHJvcEV2ZW50KiBxZGUpCiB7CiAgIGtEZWJ1Zyg1OTcwKSA8PCAiVGhpcyBpcyBkcm9w RXZlbnQiIDw8IGVuZGw7CkBAIC01NTIsNyArNjA4LDggQEAKIAogdm9pZCBUYXNrVmlldzo6Y2xl YXJBY3RpdmVUYXNrcygpCiB7Ci0gIGFjdGl2ZVRhc2tzLmNsZWFyKCk7CisgIGFjdGl2ZVRhc2tz LmNsZWFyKCk7IAorICBfZm9jdXNEZXRlY3Rvci0+c3RhcnRGb2N1c0RldGVjdGlvbigpOyAKIH0K IAogdm9pZCBUYXNrVmlldzo6c3RvcEFsbFRpbWVycyggUURhdGVUaW1lIHdoZW4gKQpAQCAtNTYy LDYgKzYxOSw3IEBACiAgICAgYWN0aXZlVGFza3MuYXQoaSktPnNldFJ1bm5pbmcoZmFsc2UsIF9z dG9yYWdlLCB3aGVuKTsKIAogICBfaWRsZVRpbWVEZXRlY3Rvci0+c3RvcElkbGVEZXRlY3Rpb24o KTsKKyAgX2ZvY3VzRGV0ZWN0b3ItPnN0b3BGb2N1c0RldGVjdGlvbigpOyAKICAgYWN0aXZlVGFz a3MuY2xlYXIoKTsKICAgZW1pdCB1cGRhdGVCdXR0b25zKCk7CiAgIGVtaXQgdGltZXJzSW5hY3Rp dmUoKTsKSW5kZXg6IENNYWtlTGlzdHMudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIENNYWtlTGlzdHMudHh0 CShyZXZpc2lvbiA2OTMwMDMpCisrKyBDTWFrZUxpc3RzLnR4dAkod29ya2luZyBjb3B5KQpAQCAt MTYsNyArMTYsNyBAQAogCWVkaXR0YXNrZGlhbG9nLmNwcCBpZGxldGltZWRldGVjdG9yLmNwcCAK IAlwcmludGRpYWxvZy5jcHAgdGltZWthcmQuY3BwIGthcm11dGlsaXR5LmNwcCBrdGltZXdpZGdl dC5jcHAKIAlrYXJtc3RvcmFnZS5jcHAgbWFpbndpbmRvdy5jcHAgcHJlZmVyZW5jZXMuY3BwIHBy aW50LmNwcCAKLQl0YXNrLmNwcCB0YXNrdmlldy5jcHAgdHJheS5jcHAgIAorCXRhc2suY3BwIHRh c2t2aWV3LmNwcCB0cmF5LmNwcCAgZm9jdXNkZXRlY3Rvci5jcHAKIAljc3ZleHBvcnRkaWFsb2cu Y3BwIHBsYW5uZXJwYXJzZXIuY3BwIAogCXRyZWV2aWV3aGVhZGVyY29udGV4dG1lbnUuY3BwIGVk aXRoaXN0b3J5ZGlhbG9nLmNwcAogICkK 21259 2007-07-27 07:04:44 +0000 2007-07-27 09:59:41 +0000 code cleanUp ktimetrackerpatch.diff text/plain 5426 dev SW5kZXg6IHRhc2t2aWV3LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gdGFza3ZpZXcuaAkocmV2aXNpb24gNjkz MDAzKQorKysgdGFza3ZpZXcuaAkod29ya2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2lu Y2x1ZGUgImRlc2t0b3BsaXN0LmgiCiAjaW5jbHVkZSAia2FybXN0b3JhZ2UuaCIKICNpbmNsdWRl ICJyZXBvcnRjcml0ZXJpYS5oIgorI2luY2x1ZGUgImZvY3VzZGV0ZWN0b3IuaCIKIAogY2xhc3Mg UU1vdXNlRXZlbnQ7CiBjbGFzcyBRU3RyaW5nOwpAQCAtOTIsNyArOTMsNyBAQAogICAgIFByZWZl cmVuY2VzICpwcmVmZXJlbmNlcygpOwogCiAgICAgLyoqIEFkZCBhIHRhc2sgdG8gdmlldyBhbmQg c3RvcmFnZS4gKi8KLSAgICBRU3RyaW5nIGFkZFRhc2soIGNvbnN0IFFTdHJpbmcmIHRhc2thbWUs IGxvbmcgdG90YWwsIGxvbmcgc2Vzc2lvbiwgY29uc3QgRGVza3RvcExpc3QmIGRlc2t0b3BzLAor ICAgIFFTdHJpbmcgYWRkVGFzayggY29uc3QgUVN0cmluZyYgdGFza2FtZSwgbG9uZyB0b3RhbCA9 IDAsIGxvbmcgc2Vzc2lvbiA9IDAsIGNvbnN0IERlc2t0b3BMaXN0JiBkZXNrdG9wcyA9IFFWZWN0 b3I8aW50PigwLDApLAogICAgICAgICAgICAgICAgICAgICAgVGFzayogcGFyZW50ID0gMCApOwog CiAgIHB1YmxpYyBRX1NMT1RTOgpAQCAtMTM4LDYgKzEzOSwxMiBAQAogICAgIC8qKiBDYWxscyBu ZXdUYXNrIGRpYWxvZyB3aXRoIGNhcHRpb24gIk5ldyBTdWIgVGFzayIuICovCiAgICAgdm9pZCBu ZXdTdWJUYXNrKCk7CiAKKyAgICAvKiogc3RhcnQgdGhlIGF1dG90cmFja2luZyBzeXN0ZW0gdG8g YWRkIHRhc2tzIHRvIGNvbnRyb2wgdGltZSBmb3IgZXZlcnkgZm9jdXNlZCB3aW5kb3dzICoqLwor ICAgIHZvaWQgc3RhcnRBdXRvVHJhY2tpbmcoKXt9OworCisgICAgLyoqIHN0b3AgdGhlIGF1dG90 cmFja2luZyBzeXN0ZW0gdG8gYWRkIHRhc2tzIHRvIGNvbnRyb2wgdGltZSBmb3IgZXZlcnkgZm9j dXNlZCB3aW5kb3dzICoqLyAgICAKKyAgICB2b2lkIHN0b3BBdXRvVHJhY2tpbmcoKXt9OworIAog ICAgIHZvaWQgZWRpdFRhc2soKTsKIAogICAgIC8qKgpAQCAtMjA4LDcgKzIxNSw4IEBACiAgICAg dm9pZCBzZXRTdGF0dXNCYXJUZXh0KFFTdHJpbmcpOwogCiAgIHByaXZhdGU6IC8vIG1lbWJlciB2 YXJpYWJsZXMKLSAgICBJZGxlVGltZURldGVjdG9yICpfaWRsZVRpbWVEZXRlY3RvcjsKKyAgICBJ ZGxlVGltZURldGVjdG9yKiBfaWRsZVRpbWVEZXRlY3RvcjsKKyAgICBGb2N1c0RldGVjdG9yKiBf Zm9jdXNEZXRlY3RvcjsKICAgICBRVGltZXIgKl9taW51dGVUaW1lcjsKICAgICBRVGltZXIgKl9h dXRvU2F2ZVRpbWVyOwogICAgIFFUaW1lciAqX21hbnVhbFNhdmVUaW1lcjsKQEAgLTIxOCw2ICsy MjYsNyBAQAogICAgIGJvb2wgX2lzbG9hZGluZzsKICAgICBUYXNrKiBkcmFnVGFzazsKICAgICBR VGFibGVXaWRnZXQqIGhpc3Rvcnl3aWRnZXQ7CisgICAgVGFzayogIGxhc3RUYXNrV2l0aEZvY3Vz OwogCiAgICAgLy9LQ2FsOjpDYWxlbmRhckxvY2FsIF9jYWxlbmRhcjsKICAgICBLYXJtU3RvcmFn ZSAqIF9zdG9yYWdlOwpAQCAtMjM5LDEyICsyNDgsMTggQEAKICAgICB2b2lkIGF1dG9TYXZlQ2hh bmdlZCggYm9vbCApOwogICAgIHZvaWQgYXV0b1NhdmVQZXJpb2RDaGFuZ2VkKCBpbnQgcGVyaW9k ICk7CiAgICAgdm9pZCBtaW51dGVVcGRhdGUoKTsKKwogICAgIC8qKiBpdGVtIHN0YXRlIHN0b3Jl cyBpZiBhIHRhc2sgaXMgZXhwYW5kZWQgc28geW91IGNhbiBzZWUgdGhlIHN1YnRhc2tzICovCiAg ICAgdm9pZCBpdGVtU3RhdGVDaGFuZ2VkKCBRVHJlZVdpZGdldEl0ZW0gKml0ZW0gKTsKKwogICAg IC8qKiBSZWFjdCBvbiBhbm90aGVyIHByb2Nlc3MgaGF2aW5nIG1vZGlmaWVkIHRoZSBpQ2FsIGZp bGUgd2UgcmVseSBvbi4gCiAgICAgICAgVGhpcyBpcyBub3QgaUNhbEZpbGVDaGFuZ2VkLiAqLwog ICAgIHZvaWQgaUNhbEZpbGVNb2RpZmllZChSZXNvdXJjZUNhbGVuZGFyICopOwogICAgIHZvaWQg c2xvdEl0ZW1Eb3VibGVDbGlja2VkKCBRVHJlZVdpZGdldEl0ZW0gKml0ZW0sIGludCApOworCisg ICAgLyoqIFJlYWN0IG9uIHRoZSBmb2N1cyBoYXZpbmcgY2hhbmdlZCB0byBXaW5kb3cgUVN0cmlu ZyAqKi8KKyAgICB2b2lkIG5ld0ZvY3VzV2luZG93RGV0ZWN0ZWQgKFFTdHJpbmcpOworCiAgICAg dm9pZCBzbG90Q29sdW1uVG9nZ2xlZCggaW50ICk7CiB9OwogCkluZGV4OiB0YXNrdmlldy5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gdGFza3ZpZXcuY3BwCShyZXZpc2lvbiA2OTMwMDMpCisrKyB0YXNrdmll dy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEwNyw2ICsxMDcsNyBAQAogewogICBfcHJlZmVyZW5j ZXMgPSBQcmVmZXJlbmNlczo6aW5zdGFuY2UoIGljc2ZpbGUgKTsKICAgX3N0b3JhZ2UgPSBLYXJt U3RvcmFnZTo6aW5zdGFuY2UoKTsKKyAgX2ZvY3VzRGV0ZWN0b3IgPSBuZXcgRm9jdXNEZXRlY3Rv cigxKTsKIAogICBjb25uZWN0KCB0aGlzLCBTSUdOQUwoaXRlbUV4cGFuZGVkKFFUcmVlV2lkZ2V0 SXRlbSopKSwKICAgICAgICAgICAgdGhpcywgU0xPVChpdGVtU3RhdGVDaGFuZ2VkKFFUcmVlV2lk Z2V0SXRlbSopKSApOwpAQCAtMTE0LDYgKzExNSw4IEBACiAgICAgICAgICAgIHRoaXMsIFNMT1Qo aXRlbVN0YXRlQ2hhbmdlZChRVHJlZVdpZGdldEl0ZW0qKSkgKTsKICAgY29ubmVjdCggdGhpcywg U0lHTkFMKGl0ZW1Eb3VibGVDbGlja2VkKFFUcmVlV2lkZ2V0SXRlbSosIGludCkpLAogICAgICAg ICAgICB0aGlzLCBTTE9UKHNsb3RJdGVtRG91YmxlQ2xpY2tlZChRVHJlZVdpZGdldEl0ZW0qLCBp bnQpKSApOworICBjb25uZWN0KCBfZm9jdXNEZXRlY3RvciwgU0lHTkFMKCBuZXdGb2N1cyhRU3Ry aW5nKSApLCAKKyAgICAgICAgICAgdGhpcywgU0xPVChuZXdGb2N1c1dpbmRvd0RldGVjdGVkIChR U3RyaW5nKSkgKTsgCiAKICAgUVN0cmluZ0xpc3QgbGFiZWxzOwogICBsYWJlbHMgPDwgaTE4bigi VGFzayBOYW1lIikgPDwgaTE4bigiU2Vzc2lvbiBUaW1lIikgPDwgaTE4bigiVGltZSIpIDw8IGkx OG4oIlRvdGFsIFNlc3Npb24gVGltZSIpIDw8IGkxOG4oIlRvdGFsIFRpbWUiKSA8PCBpMThuKCJQ ZXJjZW50IENvbXBsZXRlIikgOwpAQCAtMTc5LDYgKzE4Miw0MiBAQAogICBjb25uZWN0KCBoZWFk ZXJDb250ZXh0TWVudSwgU0lHTkFMKGNvbHVtblRvZ2dsZWQoaW50KSksIHRoaXMsIFNMT1Qoc2xv dENvbHVtblRvZ2dsZWQoaW50KSkgKTsKIH0KIAordm9pZCBUYXNrVmlldzo6bmV3Rm9jdXNXaW5k b3dEZXRlY3RlZChjb25zdCBRU3RyaW5nIHRhc2tOYW1lKQoreworICBib29sIGZvdW5kPWZhbHNl OyAgLy8gaGFzIHRhc2tOYW1lIGJlZW4gZm91bmQgaW4gb3VyIHRhc2tzCisgIHN0b3BUaW1lckZv cihsYXN0VGFza1dpdGhGb2N1cyk7CisgIGludCBpPTA7CisgIGZvciAoIFRhc2sqIHRhc2sgPSBp dGVtX2F0X2luZGV4KGkpOyB0YXNrOyB0YXNrID0gaXRlbV9hdF9pbmRleCgrK2kpICkKKyAgewor ICAgIGlmICh0YXNrLT5uYW1lKCk9PXRhc2tOYW1lKQorICAgIHsKKyAgICAgICBmb3VuZD10cnVl OworICAgICAgIHN0YXJ0VGltZXJGb3IodGFzayk7CisgICAgICAgbGFzdFRhc2tXaXRoRm9jdXM9 dGFzazsKKyAgICB9CisgIH0KKyAgaWYgICghZm91bmQpCisgIHsKKyAgICBRU3RyaW5nIHRhc2t1 aWQgPSBhZGRUYXNrKCB0YXNrTmFtZSApOworICAgIGlmICggdGFza3VpZC5pc051bGwoKSApCisg ICAgeworICAgICAgS01lc3NhZ2VCb3g6OmVycm9yKCAwLCBpMThuKAorICAgICAgIkVycm9yIHN0 b3JpbmcgbmV3IHRhc2suIFlvdXIgY2hhbmdlcyB3ZXJlIG5vdCBzYXZlZC4gTWFrZSBzdXJlIHlv dSBjYW4gZWRpdCB5b3VyIGlDYWxlbmRhciBmaWxlLiBBbHNvIHF1aXQgYWxsIGFwcGxpY2F0aW9u cyB1c2luZyB0aGlzIGZpbGUgYW5kIHJlbW92ZSBhbnkgbG9jayBmaWxlIHJlbGF0ZWQgdG8gaXRz IG5hbWUgZnJvbSB+Ly5rZGUvc2hhcmUvYXBwcy9rYWJjL2xvY2svICIgKSApOworICAgIH0KKyAg ICBpPTA7CisgICAgZm9yICggVGFzayogdGFzayA9IGl0ZW1fYXRfaW5kZXgoaSk7IHRhc2s7IHRh c2sgPSBpdGVtX2F0X2luZGV4KCsraSkgKQorICAgIHsKKyAgICAgIGlmICh0YXNrLT5uYW1lKCk9 PXRhc2tOYW1lKQorICAgICAgeworICAgICAgICBzdGFydFRpbWVyRm9yKHRhc2spOworICAgICAg ICBsYXN0VGFza1dpdGhGb2N1cz10YXNrOworICAgICAgfQorICAgIH0KKyAgfQorICBlbWl0IHVw ZGF0ZUJ1dHRvbnMoKTsKK30gCisKKwogdm9pZCBUYXNrVmlldzo6ZHJvcEV2ZW50KFFEcm9wRXZl bnQqIHFkZSkKIHsKICAga0RlYnVnKDU5NzApIDw8ICJUaGlzIGlzIGRyb3BFdmVudCIgPDwgZW5k bDsKQEAgLTU1Miw3ICs1OTEsOCBAQAogCiB2b2lkIFRhc2tWaWV3OjpjbGVhckFjdGl2ZVRhc2tz KCkKIHsKLSAgYWN0aXZlVGFza3MuY2xlYXIoKTsKKyAgYWN0aXZlVGFza3MuY2xlYXIoKTsgCisg IF9mb2N1c0RldGVjdG9yLT5zdGFydEZvY3VzRGV0ZWN0aW9uKCk7IAogfQogCiB2b2lkIFRhc2tW aWV3OjpzdG9wQWxsVGltZXJzKCBRRGF0ZVRpbWUgd2hlbiApCkBAIC01NjIsNiArNjAyLDcgQEAK ICAgICBhY3RpdmVUYXNrcy5hdChpKS0+c2V0UnVubmluZyhmYWxzZSwgX3N0b3JhZ2UsIHdoZW4p OwogCiAgIF9pZGxlVGltZURldGVjdG9yLT5zdG9wSWRsZURldGVjdGlvbigpOworICBfZm9jdXNE ZXRlY3Rvci0+c3RvcEZvY3VzRGV0ZWN0aW9uKCk7IAogICBhY3RpdmVUYXNrcy5jbGVhcigpOwog ICBlbWl0IHVwZGF0ZUJ1dHRvbnMoKTsKICAgZW1pdCB0aW1lcnNJbmFjdGl2ZSgpOwpJbmRleDog Q01ha2VMaXN0cy50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gQ01ha2VMaXN0cy50eHQJKHJldmlzaW9uIDY5 MzAwMykKKysrIENNYWtlTGlzdHMudHh0CSh3b3JraW5nIGNvcHkpCkBAIC0xNiw3ICsxNiw3IEBA CiAJZWRpdHRhc2tkaWFsb2cuY3BwIGlkbGV0aW1lZGV0ZWN0b3IuY3BwIAogCXByaW50ZGlhbG9n LmNwcCB0aW1la2FyZC5jcHAga2FybXV0aWxpdHkuY3BwIGt0aW1ld2lkZ2V0LmNwcAogCWthcm1z dG9yYWdlLmNwcCBtYWlud2luZG93LmNwcCBwcmVmZXJlbmNlcy5jcHAgcHJpbnQuY3BwIAotCXRh c2suY3BwIHRhc2t2aWV3LmNwcCB0cmF5LmNwcCAgCisJdGFzay5jcHAgdGFza3ZpZXcuY3BwIHRy YXkuY3BwICBmb2N1c2RldGVjdG9yLmNwcAogCWNzdmV4cG9ydGRpYWxvZy5jcHAgcGxhbm5lcnBh cnNlci5jcHAgCiAJdHJlZXZpZXdoZWFkZXJjb250ZXh0bWVudS5jcHAgZWRpdGhpc3RvcnlkaWFs b2cuY3BwCiAgKQo= 21263 2007-07-27 09:59:41 +0000 2007-07-27 09:59:41 +0000 this time I forgot to svn add some files ktimetrackerpatch.diff text/plain 10856 dev SW5kZXg6IHRhc2t2aWV3LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gdGFza3ZpZXcuaAkocmV2aXNpb24gNjkz MDAzKQorKysgdGFza3ZpZXcuaAkod29ya2luZyBjb3B5KQpAQCAtMzAsNiArMzAsNyBAQAogI2lu Y2x1ZGUgImRlc2t0b3BsaXN0LmgiCiAjaW5jbHVkZSAia2FybXN0b3JhZ2UuaCIKICNpbmNsdWRl ICJyZXBvcnRjcml0ZXJpYS5oIgorI2luY2x1ZGUgImZvY3VzZGV0ZWN0b3IuaCIKIAogY2xhc3Mg UU1vdXNlRXZlbnQ7CiBjbGFzcyBRU3RyaW5nOwpAQCAtOTIsNyArOTMsNyBAQAogICAgIFByZWZl cmVuY2VzICpwcmVmZXJlbmNlcygpOwogCiAgICAgLyoqIEFkZCBhIHRhc2sgdG8gdmlldyBhbmQg c3RvcmFnZS4gKi8KLSAgICBRU3RyaW5nIGFkZFRhc2soIGNvbnN0IFFTdHJpbmcmIHRhc2thbWUs IGxvbmcgdG90YWwsIGxvbmcgc2Vzc2lvbiwgY29uc3QgRGVza3RvcExpc3QmIGRlc2t0b3BzLAor ICAgIFFTdHJpbmcgYWRkVGFzayggY29uc3QgUVN0cmluZyYgdGFza2FtZSwgbG9uZyB0b3RhbCA9 IDAsIGxvbmcgc2Vzc2lvbiA9IDAsIGNvbnN0IERlc2t0b3BMaXN0JiBkZXNrdG9wcyA9IFFWZWN0 b3I8aW50PigwLDApLAogICAgICAgICAgICAgICAgICAgICAgVGFzayogcGFyZW50ID0gMCApOwog CiAgIHB1YmxpYyBRX1NMT1RTOgpAQCAtMTM4LDYgKzEzOSwxMiBAQAogICAgIC8qKiBDYWxscyBu ZXdUYXNrIGRpYWxvZyB3aXRoIGNhcHRpb24gIk5ldyBTdWIgVGFzayIuICovCiAgICAgdm9pZCBu ZXdTdWJUYXNrKCk7CiAKKyAgICAvKiogc3RhcnQgdGhlIGF1dG90cmFja2luZyBzeXN0ZW0gdG8g YWRkIHRhc2tzIHRvIGNvbnRyb2wgdGltZSBmb3IgZXZlcnkgZm9jdXNlZCB3aW5kb3dzICoqLwor ICAgIHZvaWQgc3RhcnRBdXRvVHJhY2tpbmcoKXt9OworCisgICAgLyoqIHN0b3AgdGhlIGF1dG90 cmFja2luZyBzeXN0ZW0gdG8gYWRkIHRhc2tzIHRvIGNvbnRyb2wgdGltZSBmb3IgZXZlcnkgZm9j dXNlZCB3aW5kb3dzICoqLyAgICAKKyAgICB2b2lkIHN0b3BBdXRvVHJhY2tpbmcoKXt9OworIAog ICAgIHZvaWQgZWRpdFRhc2soKTsKIAogICAgIC8qKgpAQCAtMjA4LDcgKzIxNSw4IEBACiAgICAg dm9pZCBzZXRTdGF0dXNCYXJUZXh0KFFTdHJpbmcpOwogCiAgIHByaXZhdGU6IC8vIG1lbWJlciB2 YXJpYWJsZXMKLSAgICBJZGxlVGltZURldGVjdG9yICpfaWRsZVRpbWVEZXRlY3RvcjsKKyAgICBJ ZGxlVGltZURldGVjdG9yKiBfaWRsZVRpbWVEZXRlY3RvcjsKKyAgICBGb2N1c0RldGVjdG9yKiBf Zm9jdXNEZXRlY3RvcjsKICAgICBRVGltZXIgKl9taW51dGVUaW1lcjsKICAgICBRVGltZXIgKl9h dXRvU2F2ZVRpbWVyOwogICAgIFFUaW1lciAqX21hbnVhbFNhdmVUaW1lcjsKQEAgLTIxOCw2ICsy MjYsNyBAQAogICAgIGJvb2wgX2lzbG9hZGluZzsKICAgICBUYXNrKiBkcmFnVGFzazsKICAgICBR VGFibGVXaWRnZXQqIGhpc3Rvcnl3aWRnZXQ7CisgICAgVGFzayogIGxhc3RUYXNrV2l0aEZvY3Vz OwogCiAgICAgLy9LQ2FsOjpDYWxlbmRhckxvY2FsIF9jYWxlbmRhcjsKICAgICBLYXJtU3RvcmFn ZSAqIF9zdG9yYWdlOwpAQCAtMjM5LDEyICsyNDgsMTggQEAKICAgICB2b2lkIGF1dG9TYXZlQ2hh bmdlZCggYm9vbCApOwogICAgIHZvaWQgYXV0b1NhdmVQZXJpb2RDaGFuZ2VkKCBpbnQgcGVyaW9k ICk7CiAgICAgdm9pZCBtaW51dGVVcGRhdGUoKTsKKwogICAgIC8qKiBpdGVtIHN0YXRlIHN0b3Jl cyBpZiBhIHRhc2sgaXMgZXhwYW5kZWQgc28geW91IGNhbiBzZWUgdGhlIHN1YnRhc2tzICovCiAg ICAgdm9pZCBpdGVtU3RhdGVDaGFuZ2VkKCBRVHJlZVdpZGdldEl0ZW0gKml0ZW0gKTsKKwogICAg IC8qKiBSZWFjdCBvbiBhbm90aGVyIHByb2Nlc3MgaGF2aW5nIG1vZGlmaWVkIHRoZSBpQ2FsIGZp bGUgd2UgcmVseSBvbi4gCiAgICAgICAgVGhpcyBpcyBub3QgaUNhbEZpbGVDaGFuZ2VkLiAqLwog ICAgIHZvaWQgaUNhbEZpbGVNb2RpZmllZChSZXNvdXJjZUNhbGVuZGFyICopOwogICAgIHZvaWQg c2xvdEl0ZW1Eb3VibGVDbGlja2VkKCBRVHJlZVdpZGdldEl0ZW0gKml0ZW0sIGludCApOworCisg ICAgLyoqIFJlYWN0IG9uIHRoZSBmb2N1cyBoYXZpbmcgY2hhbmdlZCB0byBXaW5kb3cgUVN0cmlu ZyAqKi8KKyAgICB2b2lkIG5ld0ZvY3VzV2luZG93RGV0ZWN0ZWQgKFFTdHJpbmcpOworCiAgICAg dm9pZCBzbG90Q29sdW1uVG9nZ2xlZCggaW50ICk7CiB9OwogCkluZGV4OiBmb2N1c2RldGVjdG9y LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gZm9jdXNkZXRlY3Rvci5oCShyZXZpc2lvbiAwKQorKysgZm9jdXNk ZXRlY3Rvci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDgwIEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDA3IFJlbsOpIE3DqXJvdQorICoKKyAqICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAqICAgaXQgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNo ZWQgYnkKKyAqICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24g MiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqICAgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVy c2lvbi4KKyAqCisgKiAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogICBNRVJDSEFOVEFCSUxJVFkg b3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisgKiAgIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogICBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBhbG9uZworICogICB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUKKyAq IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLgorICogNTEgRnJhbmtsaW4gU3RyZWV0LCBG aWZ0aCBGbG9vcgorICogQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBLgorICoKKyAqICBhdCBz aG9ydCBMb2dpYyB0aGF0IGdldHMgYW5kIHN0b3JlcyB0YXNrcyBmcm9tIGZvY3VzZWQgd2luZG93 cy4KKyAqICBhdCBhdXRob3IgUmVuw6kgTcOpcm91IDxvY2hvbWludXRvc2RlYXJjbyBhdCBnbWFp bC5jb20+CisgKi8KKworI2lmbmRlZiBLQVJNX0ZPQ1VTX0RFVEVDVE9SX0gKKyNkZWZpbmUgS0FS TV9GT0NVU19ERVRFQ1RPUl9ICisKKyNpbmNsdWRlIDxRRGF0ZVRpbWU+CisjaW5jbHVkZSA8UU9i amVjdD4KKyNpbmNsdWRlICJjb25maWcta2FybS5oIiAvLyBIQVZFX0xJQlhTUworCitjbGFzcyBR VGltZXI7CisKK2NvbnN0IGludCBwZXJpb2RJbnRlcnZhbCA9IDEwMDA7CisKKy8qKgorICogS2Vl cCB0cmFjayBvZiB3aGF0IHdpbmRvdyBoYXMgdGhlIGZvY3VzLgorICovCisKK2NsYXNzIEZvY3Vz RGV0ZWN0b3IgOnB1YmxpYyBRT2JqZWN0Cit7CitRX09CSkVDVAorCitwdWJsaWM6CisgIC8qKgor ICAgICBJbml0aWFsaXplcyB0aGUgdGltZSBwZXJpb2QKKyAgICAgIGF0IHBhcmFtIHBlcmlvZEZv Y3VzIG1pbnV0ZXMgYmVmb3JlIGV2ZXJ5IGZvY3VzIGRldGVjdGlvbi4KKyAgKiovCisgIEZvY3Vz RGV0ZWN0b3IoaW50IHBlcmlvZEZvY3VzKTsKKworICAvKioKKyAgICAgU2V0cyB0aGUgcGVyaW9k IG9mIHRpbWUgYmVmb3JlIGV2ZXJ5IGZvY3VzIHNlYXJjaC4KKyAgICAgIGF0IHBhcmFtIHBlcmlv ZEZvY3VzIHBlcmlvZCBvZiB0aW1lIGluIG1pbnV0ZXMKKyAgKiovCisgIHZvaWQgc2V0UGVyaW9k Rm9jdXMoaW50IHBlcmlvZEZvY3VzKTsKKworICAvKioKKyAgICAgU3RhcnRzIGRldGVjdGluZyBm b2N1cworICAqKi8KKyAgdm9pZCBzdGFydEZvY3VzRGV0ZWN0aW9uKCk7CisKKyAgLyoqCisgICAg ICBTdG9wcyBkZXRlY3RpbmcgZm9jdXMuCisgICoqLworICB2b2lkIHN0b3BGb2N1c0RldGVjdGlv bigpOworCitzaWduYWxzOgorICAgIHZvaWQgbmV3Rm9jdXMoUVN0cmluZyk7CisKK3Byb3RlY3Rl ZCBzbG90czoKKyAgdm9pZCBjaGVjaygpOworCitwcml2YXRlOgorICBpbnQgX3BlcmlvZEZvY3Vz OworICBRVGltZXIgKl90aW1lcjsKKyAgUURhdGVUaW1lIHN0YXJ0OyAvLyB3aGVuIHRoZSBwZXJp b2RGb2N1cyByZXN0YXJ0ZWQKKworfTsKKworI2VuZGlmIC8vIEtBUk1fRk9DVVNfREVURUNUT1Jf SCAKKwpJbmRleDogdGFza3ZpZXcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHRhc2t2aWV3LmNwcAkocmV2 aXNpb24gNjkzMDAzKQorKysgdGFza3ZpZXcuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMDcsNiAr MTA3LDcgQEAKIHsKICAgX3ByZWZlcmVuY2VzID0gUHJlZmVyZW5jZXM6Omluc3RhbmNlKCBpY3Nm aWxlICk7CiAgIF9zdG9yYWdlID0gS2FybVN0b3JhZ2U6Omluc3RhbmNlKCk7CisgIF9mb2N1c0Rl dGVjdG9yID0gbmV3IEZvY3VzRGV0ZWN0b3IoMSk7CiAKICAgY29ubmVjdCggdGhpcywgU0lHTkFM KGl0ZW1FeHBhbmRlZChRVHJlZVdpZGdldEl0ZW0qKSksCiAgICAgICAgICAgIHRoaXMsIFNMT1Qo aXRlbVN0YXRlQ2hhbmdlZChRVHJlZVdpZGdldEl0ZW0qKSkgKTsKQEAgLTExNCw2ICsxMTUsOCBA QAogICAgICAgICAgICB0aGlzLCBTTE9UKGl0ZW1TdGF0ZUNoYW5nZWQoUVRyZWVXaWRnZXRJdGVt KikpICk7CiAgIGNvbm5lY3QoIHRoaXMsIFNJR05BTChpdGVtRG91YmxlQ2xpY2tlZChRVHJlZVdp ZGdldEl0ZW0qLCBpbnQpKSwKICAgICAgICAgICAgdGhpcywgU0xPVChzbG90SXRlbURvdWJsZUNs aWNrZWQoUVRyZWVXaWRnZXRJdGVtKiwgaW50KSkgKTsKKyAgY29ubmVjdCggX2ZvY3VzRGV0ZWN0 b3IsIFNJR05BTCggbmV3Rm9jdXMoUVN0cmluZykgKSwgCisgICAgICAgICAgIHRoaXMsIFNMT1Qo bmV3Rm9jdXNXaW5kb3dEZXRlY3RlZCAoUVN0cmluZykpICk7IAogCiAgIFFTdHJpbmdMaXN0IGxh YmVsczsKICAgbGFiZWxzIDw8IGkxOG4oIlRhc2sgTmFtZSIpIDw8IGkxOG4oIlNlc3Npb24gVGlt ZSIpIDw8IGkxOG4oIlRpbWUiKSA8PCBpMThuKCJUb3RhbCBTZXNzaW9uIFRpbWUiKSA8PCBpMThu KCJUb3RhbCBUaW1lIikgPDwgaTE4bigiUGVyY2VudCBDb21wbGV0ZSIpIDsKQEAgLTE3OSw2ICsx ODIsNDYgQEAKICAgY29ubmVjdCggaGVhZGVyQ29udGV4dE1lbnUsIFNJR05BTChjb2x1bW5Ub2dn bGVkKGludCkpLCB0aGlzLCBTTE9UKHNsb3RDb2x1bW5Ub2dnbGVkKGludCkpICk7CiB9CiAKK3Zv aWQgVGFza1ZpZXc6Om5ld0ZvY3VzV2luZG93RGV0ZWN0ZWQoY29uc3QgUVN0cmluZyB0YXNrTmFt ZSkKK3sKKyAgYm9vbCBmb3VuZD1mYWxzZTsgIC8vIGhhcyB0YXNrTmFtZSBiZWVuIGZvdW5kIGlu IG91ciB0YXNrcworICBzdG9wVGltZXJGb3IobGFzdFRhc2tXaXRoRm9jdXMpOworICBpbnQgaT0w OworICBmb3IgKCBUYXNrKiB0YXNrID0gaXRlbV9hdF9pbmRleChpKTsgdGFzazsgdGFzayA9IGl0 ZW1fYXRfaW5kZXgoKytpKSApCisgIHsKK2tEZWJ1ZygpIDw8ICJ0YXNrTmFtZT0iIDw8IHRhc2tO YW1lIDw8ICIsIHRhc2stPm5hbWUoKT0gIiA8PCB0YXNrLT5uYW1lKCkgPDwgICIuIiA8PCBlbmRs OworICAgIFFTdHJpbmcgcTE9dGFza05hbWU7CisgICAgcTEucmVwbGFjZSgiXG4iLCIiKTsKKyAg ICBRU3RyaW5nIHEyPXRhc2stPm5hbWUoKTsKKyAgICBpZiAocTE9PXEyKQorICAgIHsKKyAgICAg ICBmb3VuZD10cnVlOworICAgICAgIHN0YXJ0VGltZXJGb3IodGFzayk7CisgICAgICAgbGFzdFRh c2tXaXRoRm9jdXM9dGFzazsKKyAgICB9CisgIH0KKyAgaWYgICghZm91bmQpCisgIHsKKyAgICBR U3RyaW5nIHRhc2t1aWQgPSBhZGRUYXNrKCB0YXNrTmFtZSApOworICAgIGlmICggdGFza3VpZC5p c051bGwoKSApCisgICAgeworICAgICAgS01lc3NhZ2VCb3g6OmVycm9yKCAwLCBpMThuKAorICAg ICAgIkVycm9yIHN0b3JpbmcgbmV3IHRhc2suIFlvdXIgY2hhbmdlcyB3ZXJlIG5vdCBzYXZlZC4g TWFrZSBzdXJlIHlvdSBjYW4gZWRpdCB5b3VyIGlDYWxlbmRhciBmaWxlLiBBbHNvIHF1aXQgYWxs IGFwcGxpY2F0aW9ucyB1c2luZyB0aGlzIGZpbGUgYW5kIHJlbW92ZSBhbnkgbG9jayBmaWxlIHJl bGF0ZWQgdG8gaXRzIG5hbWUgZnJvbSB+Ly5rZGUvc2hhcmUvYXBwcy9rYWJjL2xvY2svICIgKSAp OworICAgIH0KKyAgICBpPTA7CisgICAgZm9yICggVGFzayogdGFzayA9IGl0ZW1fYXRfaW5kZXgo aSk7IHRhc2s7IHRhc2sgPSBpdGVtX2F0X2luZGV4KCsraSkgKQorICAgIHsKKyAgICAgIGlmICh0 YXNrLT5uYW1lKCk9PXRhc2tOYW1lKQorICAgICAgeworICAgICAgICBzdGFydFRpbWVyRm9yKHRh c2spOworICAgICAgICBsYXN0VGFza1dpdGhGb2N1cz10YXNrOworICAgICAgfQorICAgIH0KKyAg fQorICBlbWl0IHVwZGF0ZUJ1dHRvbnMoKTsKK30gCisKKwogdm9pZCBUYXNrVmlldzo6ZHJvcEV2 ZW50KFFEcm9wRXZlbnQqIHFkZSkKIHsKICAga0RlYnVnKDU5NzApIDw8ICJUaGlzIGlzIGRyb3BF dmVudCIgPDwgZW5kbDsKQEAgLTU1Miw3ICs1OTUsOCBAQAogCiB2b2lkIFRhc2tWaWV3OjpjbGVh ckFjdGl2ZVRhc2tzKCkKIHsKLSAgYWN0aXZlVGFza3MuY2xlYXIoKTsKKyAgYWN0aXZlVGFza3Mu Y2xlYXIoKTsgCisgIF9mb2N1c0RldGVjdG9yLT5zdGFydEZvY3VzRGV0ZWN0aW9uKCk7IAogfQog CiB2b2lkIFRhc2tWaWV3OjpzdG9wQWxsVGltZXJzKCBRRGF0ZVRpbWUgd2hlbiApCkBAIC01NjIs NiArNjA2LDcgQEAKICAgICBhY3RpdmVUYXNrcy5hdChpKS0+c2V0UnVubmluZyhmYWxzZSwgX3N0 b3JhZ2UsIHdoZW4pOwogCiAgIF9pZGxlVGltZURldGVjdG9yLT5zdG9wSWRsZURldGVjdGlvbigp OworICBfZm9jdXNEZXRlY3Rvci0+c3RvcEZvY3VzRGV0ZWN0aW9uKCk7IAogICBhY3RpdmVUYXNr cy5jbGVhcigpOwogICBlbWl0IHVwZGF0ZUJ1dHRvbnMoKTsKICAgZW1pdCB0aW1lcnNJbmFjdGl2 ZSgpOwpJbmRleDogZm9jdXNkZXRlY3Rvci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gZm9jdXNkZXRlY3Rv ci5jcHAJKHJldmlzaW9uIDApCisrKyBmb2N1c2RldGVjdG9yLmNwcAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSw4NSBAQAorLyoKKyogQ29weXJpZ2h0IChDKSAyMDA3IFJlbsOpIE3DqXJvdQorKgor KiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IgbW9kaWZ5CisqICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyogICB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgorKiAgIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisqCisqICAgVGhpcyBwcm9ncmFtIGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisqICAgYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YK KyogICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCisqICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKyoKKyogICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZworKiAgIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3Qs IHdyaXRlIHRvIHRoZQorKiBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKyogNTEgRnJh bmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vcgorKiBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0Eu CisqCisqICBhdCBzaG9ydCBMb2dpYyB0aGF0IGdldHMgYW5kIHN0b3JlcyB0YXNrcyBmcm9tIGZv Y3VzZWQgd2luZG93cy4KKyogIGF0IGF1dGhvciBSZW7DqSBNw6lyb3UgPG9jaG9taW51dG9zZGVh cmNvIGF0IGdtYWlsLmNvbT4KKyovCisjaW5jbHVkZSA8UVByb2Nlc3M+CisjaW5jbHVkZSAiZm9j dXNkZXRlY3Rvci5oIgorCisjaW5jbHVkZSA8cWRhdGV0aW1lLmg+CisjaW5jbHVkZSA8cW1lc3Nh Z2Vib3guaD4KKyNpbmNsdWRlIDxxdGltZXIuaD4KKworI2luY2x1ZGUgPGtkaWFsb2cuaD4KKyNp bmNsdWRlIDxrZ2xvYmFsLmg+CisjaW5jbHVkZSA8a2xvY2FsZS5oPiAvLyBpMThuCisjaW5jbHVk ZSA8UUxhYmVsPgorI2luY2x1ZGUgPFFIQm94TGF5b3V0PgorI2luY2x1ZGUgPFFWQm94TGF5b3V0 PgorI2lmZGVmIFFfV1NfWDExCisjaW5jbHVkZSA8UVgxMUluZm8+CisjZW5kaWYKKyBRU3RyaW5n IGxhc3RXaW5kb3c9IiI7CitGb2N1c0RldGVjdG9yOjpGb2N1c0RldGVjdG9yKGludCBwZXJpb2RG b2N1cykKK3sKKyAgX3RpbWVyID0gbmV3IFFUaW1lcih0aGlzKTsKKyAgY29ubmVjdChfdGltZXIs IFNJR05BTCh0aW1lb3V0KCkpLCB0aGlzLCBTTE9UKGNoZWNrKCkpKTsKKyAgX3RpbWVyLT5zdGFy dCgxMDAwKnBlcmlvZEZvY3VzKTsKK30KKwordm9pZCBGb2N1c0RldGVjdG9yOjpjaGVjaygpCit7 CisgIFFQcm9jZXNzIGZvY3VzUXVlc3Rpb247CisgIFFTdHJpbmcgY21kPSIuL2dldGFjdGl2ZXdp bmRvd3RpdGxlIjsKKyAgUVN0cmluZyBzeXNhbnN3ZXI7CisgIGZvY3VzUXVlc3Rpb24uc2V0UHJv Y2Vzc0NoYW5uZWxNb2RlKFFQcm9jZXNzOjpNZXJnZWRDaGFubmVscyk7CisgIGZvY3VzUXVlc3Rp b24uc3RhcnQoIGNtZCApOworCisgIGlmICghZm9jdXNRdWVzdGlvbi53YWl0Rm9yRmluaXNoZWQo KSkKKyAgICBrRGVidWcoKSA8PCAiQ29tbWFuZCAiIDw8IGNtZCA8PCAiIGZhaWxlZDoiIDw8IGZv Y3VzUXVlc3Rpb24uZXJyb3JTdHJpbmcoKTsKKyAgZWxzZQorICAgIHN5c2Fuc3dlcj1mb2N1c1F1 ZXN0aW9uLnJlYWRBbGwoKTsKKyAga0RlYnVnKCkgPDwgInN5c2Fuc3dlcj0iIDw8IHN5c2Fuc3dl ciA8PCBlbmRsOworICBpZiAobGFzdFdpbmRvdyE9c3lzYW5zd2VyKSAKKyAgeworICAgIGxhc3RX aW5kb3c9c3lzYW5zd2VyOworICAgIGtEZWJ1ZygpIDw8ICJORVcgV0lORE9XIFdJVEggRk9DVVM7 IFNlbmRpbmcgc2lnbmFsOiIgIDw8IGVuZGw7CisgICAgZW1pdCAobmV3Rm9jdXMoc3lzYW5zd2Vy KSk7CisgIH0KK30KKwordm9pZCBGb2N1c0RldGVjdG9yOjpzZXRQZXJpb2RGb2N1cyhpbnQgcGVy aW9kRm9jdXMpCit7CisgIF9wZXJpb2RGb2N1cyA9IHBlcmlvZEZvY3VzOworfQorCit2b2lkIEZv Y3VzRGV0ZWN0b3I6OnN0YXJ0Rm9jdXNEZXRlY3Rpb24oKQoreworICBpZiAoIV90aW1lci0+aXNB Y3RpdmUoKSkKKyAgICBfdGltZXItPnN0YXJ0KHBlcmlvZEludGVydmFsKTsKK30KKwordm9pZCBG b2N1c0RldGVjdG9yOjpzdG9wRm9jdXNEZXRlY3Rpb24oKQoreworICBpZiAoX3RpbWVyLT5pc0Fj dGl2ZSgpKQorICAgIF90aW1lci0+c3RvcCgpOworfQorCisjaW5jbHVkZSAiZm9jdXNkZXRlY3Rv ci5tb2MiIApJbmRleDogZ2V0YWN0aXZld2luZG93dGl0bGUKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gZ2V0YWN0 aXZld2luZG93dGl0bGUJKHJldmlzaW9uIDApCisrKyBnZXRhY3RpdmV3aW5kb3d0aXRsZQkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACisjIS9iaW4vYmFzaAoreHdpbmluZm8gLWlkICQoeHBy b3AgLXJvb3QgfCBncmVwICJORVRfQUNUSVZFX1dJTkRPVyhXSU5ET1cpOiIgfCBzZWQgInMvX05F VF9BQ1RJVkVfV0lORE9XKFdJTkRPVyk6IHdpbmRvdyBpZCAjIC8vIikgfCBncmVwIHh3aW5pbmZv IHwgc2VkICJzL3h3aW5pbmZvOiBXaW5kb3cgaWQ6IDB4WzAtOWEtZl0qIC8vIiB8IHNlZCAicy9e XCIvLyIgfCBzZWQgInMvXCIkLy8iIHwgc2VkICJzL1xyLy8iCisKClByb3BlcnR5IGNoYW5nZXMg b246IGdldGFjdGl2ZXdpbmRvd3RpdGxlCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTmFtZTogc3ZuOmV4ZWN1dGFibGUK ICAgKyAqCgpJbmRleDogQ01ha2VMaXN0cy50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gQ01ha2VMaXN0cy50 eHQJKHJldmlzaW9uIDY5MzAwMykKKysrIENNYWtlTGlzdHMudHh0CSh3b3JraW5nIGNvcHkpCkBA IC0xNiw3ICsxNiw3IEBACiAJZWRpdHRhc2tkaWFsb2cuY3BwIGlkbGV0aW1lZGV0ZWN0b3IuY3Bw IAogCXByaW50ZGlhbG9nLmNwcCB0aW1la2FyZC5jcHAga2FybXV0aWxpdHkuY3BwIGt0aW1ld2lk Z2V0LmNwcAogCWthcm1zdG9yYWdlLmNwcCBtYWlud2luZG93LmNwcCBwcmVmZXJlbmNlcy5jcHAg cHJpbnQuY3BwIAotCXRhc2suY3BwIHRhc2t2aWV3LmNwcCB0cmF5LmNwcCAgCisJdGFzay5jcHAg dGFza3ZpZXcuY3BwIHRyYXkuY3BwICBmb2N1c2RldGVjdG9yLmNwcAogCWNzdmV4cG9ydGRpYWxv Zy5jcHAgcGxhbm5lcnBhcnNlci5jcHAgCiAJdHJlZXZpZXdoZWFkZXJjb250ZXh0bWVudS5jcHAg ZWRpdGhpc3RvcnlkaWFsb2cuY3BwCiAgKQo= 21282 2007-07-28 19:34:27 +0000 2007-07-28 19:34:27 +0000 now in C code, not in bash patch.diff text/plain 3251 dev SW5kZXg6IGthcm11dGlsaXR5LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0ga2FybXV0aWxpdHkuaAkocmV2aXNp b24gNjkzNjA4KQorKysga2FybXV0aWxpdHkuaAkod29ya2luZyBjb3B5KQpAQCAtMzMsNSArMzMs NiBAQAogICoKICAqLwogUVN0cmluZyBmb3JtYXRUaW1lKCBsb25nIG1pbnV0ZXMsIGJvb2wgZGVj aW1hbD1mYWxzZSApOworUVN0cmluZyBnZXRmb2N1c3dpbmRvdygpOwogCiAjZW5kaWYKSW5kZXg6 IGZvY3VzZGV0ZWN0b3IuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGZvY3VzZGV0ZWN0b3IuY3BwCShyZXZp c2lvbiA2OTM2MDgpCisrKyBmb2N1c2RldGVjdG9yLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjEs NiArMjEsOCBAQAogKiAgYXQgYXV0aG9yIFJlbsOpIE3DqXJvdSA8b2Nob21pbnV0b3NkZWFyY28g YXQgZ21haWwuY29tPgogKi8KIAorI2luY2x1ZGUgPHFkYXRhc3RyZWFtLmg+CisjaW5jbHVkZSA8 cXRleHRzdHJlYW0uaD4KICNpbmNsdWRlICJmb2N1c2RldGVjdG9yLmgiCiAKICNpbmNsdWRlIDxR UHJvY2Vzcz4KQEAgLTMxLDYgKzMzLDcgQEAKICNpZmRlZiBRX1dTX1gxMQogI2luY2x1ZGUgPFFY MTFJbmZvPgogI2VuZGlmCisjaW5jbHVkZSA8WDExL1hsaWIuaD4KIAogRm9jdXNEZXRlY3Rvcjo6 Rm9jdXNEZXRlY3RvciggaW50IHBlcmlvZEZvY3VzICkKIHsKQEAgLTU1LDEyICs1OCwyNyBAQAog ICBmb2N1c1F1ZXN0aW9uLnNldFByb2Nlc3NDaGFubmVsTW9kZSggUVByb2Nlc3M6Ok1lcmdlZENo YW5uZWxzICk7CiAgIGZvY3VzUXVlc3Rpb24uc3RhcnQoIGNtZCApOwogCisKICAgaWYgKCAhZm9j dXNRdWVzdGlvbi53YWl0Rm9yRmluaXNoZWQoKSApCiAgICAga0RlYnVnKCkgPDwgIkNvbW1hbmQg IiA8PCBjbWQgPDwgIiBmYWlsZWQ6IiA8PCBmb2N1c1F1ZXN0aW9uLmVycm9yU3RyaW5nKCk7CiAg IGVsc2UKICAgICBzeXNhbnN3ZXIgPSBmb2N1c1F1ZXN0aW9uLnJlYWRBbGwoKTsKIAorICAvLyBn ZXQgdGhlIG5hbWUgb2YgdGhlIHdpbmRvdyB0aGF0IGhhcyB0aGUgZm9jdXMKKyAgRGlzcGxheSog ZGlzcGxheT0gWE9wZW5EaXNwbGF5KE5VTEwpOworICBjaGFyKiBuYW1lPSJibGFoYmxhaCI7Cisg IFdpbmRvdyB3aW5kb3c9MDsKKyAgaW50IGk9MDsKKyAgWEdldElucHV0Rm9jdXMoZGlzcGxheSwg JndpbmRvdywgJmkpOworICBpbnQgIHN0YXR1cyA9IFhGZXRjaE5hbWUgKGRpc3BsYXksIHdpbmRv dyAsICZuYW1lKTsKKworICBYQ2xvc2VEaXNwbGF5KCBkaXNwbGF5ICk7CisgIHByaW50ZigiJWki LGkpOworICBwcmludGYoIiVpIix3aW5kb3cpOworICBwcmludGYobmFtZSk7CisgCiAgIGtEZWJ1 ZygpIDw8ICJzeXNhbnN3ZXI9IiA8PCBzeXNhbnN3ZXIgPDwgZW5kbDsKKyAga0RlYnVnKCkgPDwg IndpbmRvdyBpcyAiIDw8IG5hbWUgPDwgZW5kbDsKICAgaWYgKCBsYXN0V2luZG93ICE9IHN5c2Fu c3dlciApIHsKICAgICBsYXN0V2luZG93ID0gc3lzYW5zd2VyOwogICAgIGtEZWJ1ZygpIDw8ICJO RVcgV0lORE9XIFdJVEggRk9DVVM7IFNlbmRpbmcgc2lnbmFsOiIgPDwgZW5kbDsKSW5kZXg6IG1h aW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIG1haW4uY3BwCShyZXZpc2lvbiA2OTM2MDgpCisrKyBtYWlu LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjAsMTcgKzIwLDE3IEBACiAgKi8KIAogI2luY2x1ZGUg PHNpZ25hbC5oPgotCiAjaW5jbHVkZSA8S0Fib3V0RGF0YT4KICNpbmNsdWRlIDxLQ21kTGluZUFy Z3M+CiAjaW5jbHVkZSA8S0RlYnVnPgogI2luY2x1ZGUgPEtMb2NhbGU+CiAjaW5jbHVkZSA8S1Vu aXF1ZUFwcGxpY2F0aW9uPgogCisjaW5jbHVkZSA8bmV0d20uaD4KICNpbmNsdWRlICJ2ZXJzaW9u LmgiCiAjaW5jbHVkZSAibWFpbndpbmRvdy5oIgorI2luY2x1ZGUgImthcm11dGlsaXR5LmgiCiAK LQogbmFtZXNwYWNlCiB7CiAgIGNvbnN0IGNoYXIqIGRlc2NyaXB0aW9uID0gSTE4Tl9OT09QKCJL REUgVGltZSB0cmFja2VyIHRvb2wiKTsKQEAgLTQ0LDYgKzQ0LDExIEBACiAKIGludCBtYWluKCBp bnQgYXJnYywgY2hhciAqYXJndltdICkKIHsKKyAgY29uc3QgdW5zaWduZWQgbG9uZyAgIHByb3Bl cnRpZXNbMF09e307CisgIGdldGZvY3Vzd2luZG93KCk7CisgIGludCAgIHByb3BlcnRpZXNfc2l6 ZT0wOworICBEaXNwbGF5KiBkaXNwbGF5PSBYT3BlbkRpc3BsYXkoMCk7CisgIE5FVFJvb3RJbmZv KiBuMT1uZXcgTkVUUm9vdEluZm8oZGlzcGxheSwgcHJvcGVydGllcywgcHJvcGVydGllc19zaXpl KTsKICAgS0Fib3V0RGF0YSBhYm91dERhdGEoICJrYXJtIiwgMCwga2kxOG4oIktUaW1lVHJhY2tl ciIpLAogICAgICAgS1RJTUVUUkFDS0VSX1ZFUlNJT04sIGtpMThuKGRlc2NyaXB0aW9uKSwgS0Fi b3V0RGF0YTo6TGljZW5zZV9HUEwsCiAgICAgICBraTE4bigiKGMpIDE5OTctMjAwNywgS0RFIFBJ TSBEZXZlbG9wZXJzIikgKTsKSW5kZXg6IGthcm11dGlsaXR5LmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBr YXJtdXRpbGl0eS5jcHAJKHJldmlzaW9uIDY5MzYwOCkKKysrIGthcm11dGlsaXR5LmNwcAkod29y a2luZyBjb3B5KQpAQCAtMjYsNyArMjYsMjQgQEAKICNpbmNsdWRlIDxLTG9jYWxlPgogCiAjaW5j bHVkZSAia2FybXV0aWxpdHkuaCIKKyNpbmNsdWRlIDxYMTEvWGxpYi5oPgorI2luY2x1ZGUgPGZp eHgxMWguaD4KIAorUVN0cmluZyBnZXRmb2N1c3dpbmRvdygpCit7CisgIERpc3BsYXkqIGRpc3Bs YXk9IFhPcGVuRGlzcGxheShOVUxMKTsKKyAgY2hhciogbmFtZT0iYmxhaGJsYWgiOworICBXaW5k b3cgd2luZG93PTA7CisgIGludCBpPTA7CisgIFhHZXRJbnB1dEZvY3VzKGRpc3BsYXksICZ3aW5k b3csICZpKTsKKyAgaW50ICBzdGF0dXMgPSBYRmV0Y2hOYW1lIChkaXNwbGF5LCB3aW5kb3cgLCAm bmFtZSk7CisKKyAgWENsb3NlRGlzcGxheSggZGlzcGxheSApOworICBwcmludGYoIiVpIixpKTsK KyAgcHJpbnRmKCIlaSIsd2luZG93KTsKKyAgcHJpbnRmKG5hbWUpOworfQorCiBRU3RyaW5nIGZv cm1hdFRpbWUoIGxvbmcgbWludXRlcywgYm9vbCBkZWNpbWFsICkKIHsKICAgUVN0cmluZyB0aW1l Owo=