Skeduler 2.0 (Beta, discontinued)

Skeduler 2 is a great scheduling application. You want to run an application at a specific date and time? Skeduler 2 is the solution.



Features:
The application has many features:

• Create tasks with a huge number of options

• You can specify any task name and description to easily identify them: 

• Launch any application or file, and also use command line arguments

• Execute the task at a specific date and time, and repeat for a number of times at a given interval

• Execute the task based on a daily schedule, and repeat the task ending at a specific time of day, every given interval

• Kill the task after a specific time, using various methods (wait for process to respond, or kill it forcefully).
• 

• Control your tasks at any time, activate, deactivate or edit them

 

• Save your tasks to disk, and import it on another computer

• Save all the tasks to disk in a list, and import all of them on another computer

• View a full log with all the important events

 

• Close application automatically after a given interval, or at a specific time

 

• Enable password protection, to avoid having unauthorized people exiting the application 

 

• Show a tray icon, for quick access, and to free the taskbar

 

• Load tasks or lists automatically at application start up

Download location:
You can download the application here (.exe, 4,115kb), and the source code here (.zip, 19,711kb).

Author: Chibici Tiberiu

Notes:
The application is in beta stage, this means that it still has bugs, or it may malfunction.
The application has been discontinued, if you would like to continue developing it, you can send me an email, so that updates will appear on this blog.

Tibi's Line Counter v1.0

The following application has a very simple role: count how many lines of code you wrote.

Features:
You can add a folder or a file to the list using the 'drag and drop' method. When you added all folders/files, press Calculate. The program will do the hard work of counting all the lines, and summing those together. The folders are checked recursively.

One of the cool features is the file filter, which works for all the folders in the list. Filters will eliminate unwanted files (such as executables).

Using the file filter you can look for a specific file, for example:

source_code.c

Wildcards are also available:

source*.c

source?.c

Also, you can specify multiple filters, using comma(,) or vertical bar separator (|):

*.c|*.h

*.cpp,*.h

There are some predefined macros that you can use. Note that you cannot use multiple macros, if you try to, they will be considered file names.
All - all files
All known text - a huge list of plain text formats (includes all formats below)
Scripts - many script files, including makefiles, batch, shell, applescript, lua, php etc.
Source - a huge number of source code files, including ada, assembly, C/C++, C#, Java, pascal etc.
Text - ordinary text files
Web - most used web files, such as xml, html, php etc.


System requirements:
To run the application, you need to make sure you have installed .NET Framework 3.0.

Download link:
You can download here (.exe, 28kb, dropbox.com) or here (.zip, 13kb, dropbox.com).
The source code is also available for download here (.zip, 113kb, dropbox.com, VS2010 project)

Author:
(c) 2011 Chibici Tiberiu.

Other info:
You can write a comment on this post, for feature requests, or bugs.
Here is the full list of formats used by the macros for the interested.
Large projects (e.g. >1000 files, or >100 mb) may take longer to process. This is because the application has to read all the filtered files.

LUX Operating System build 0.1.0.361 (08/24/2011): back in business

The lux operating system is back in business. The old project, CTA OS was completely rewritten, and now has a new name: lux. This time, the bootloader used is Grub.

Here are some screenshots of the latest build:

The operating system now has a logging system, which shows what is going on. It can also be turned off, at compile time. It is planned to expand this feature, the log to be written to files and optionally to the console, once the file systems are implemented.

Keyboard driver is implemented, and also mouse driver... the white cursor you see is in fact the mouse cursor.

The console is colorful as always...  however, development on the console will not continue until it is moved in user space.

A new nice feature of the console, it displays a full memory map (red blocks are used, green are free).

Floppy driver is implemented, and it was tested and works on real hardware. However, I have only tested on 3.5" 1.44 MB disks.

OSDEV Series - Episode 1.4: Short recap

In this episode, we set up a proper environment for Windows. Unlike Linux, where things are much easier, on Windows we have to build ourselves the tools that we have to use.

Download list:

• Virtual Floppy Drive: http://sourceforge.net/projects/vfd/
• GRUB 0.97: http://ftp.kaist.ac.kr/gnu-alpha/grub/grub-0.97-i386-pc.tar.gz
• Binutils Source Code: ftp://ftp.gnu.org/gnu/binutils/
• GCC Source Code: ftp://ftp.gnu.org/gnu/gcc/

Creating GRUB floppy image
Same as under Linux (Episode 1.3), except that we use Virtual Floppy Drive (VFD) instead of mount.

Building binutils and GCC
Step 1: System requirements
Make sure you have enough disk space (my installation of Cygwin had 1.6 GB after building and installing everything), and enough RAM memory (at least 512 MB).


Step 2: Download necessary tools
There are some additional tools you need for the build. To install them, you need to run the Cygwin installation. If you deleted the file, you can download it here. Install the following packages:

• Devel > bison
• Devel > flex
• Devel > gcc
• Devel > gcc-core
• Devel > gcc-g++
• Devel > make
• Libs > libgmp-devel 
• Libs > libmpfr-devel 
• Libs > libmpc-devel

Step 3: Remove other GCC ports
If you have MinGW or DJGPP installed, you will need to rename the folder they are located in. For example, you can add an underscore at the end of the folder name. This way, GCC and binutils won't find them, and won't use them. If you don't, the build could fail.


Step 4: Download the source code
Use the links provided above to download binutils and GCC source code. Unpack them in the /usr/src folder, this is usually found in [cygwin_installation]\usr\src (default is C:\cygwin\usr\src). You should use 7zip, WinRar, or the tar command in cygwin to do this, otherwise the build could fail.



Step 5: Preparation
Launch Cygwin, and type the following commands:

export PREFIX=/usr/local/cross
export TARGET=i586-elf
cd /usr/src
mkdir build-binutils build-gcc

The first two commands will create two environment variables. PREFIX is where binutils and GCC will be installed, and TARGET is what platform they will create executables for.
Then we create two directories in /usr/src, which will be used to build these tools.


Step 6: Build and install binutils
Type the following commands:

cd /usr/src/build-binutils
../binutils-x.xx/configure --target=$TARGET --prefix=$PREFIX --disable-nls
make all
make install

Replace x.xx with the version number (you can press TAB to autocomplete in Cygwin).
So we configure binutils, build it, and then install it.


Step 7: Build and install GCC
Type the following commands:

cd /usr/src/build-gcc
export PATH=$PATH:$PREFIX/bin
../gcc-x.x.x/configure --target=$TARGET --prefix=$PREFIX --disable-nls --enable-languages=c,c++ --without-headers
make all-gcc
make install-gcc

Replace x.x.x with the version number (you can press TAB to autocomplete).
Now we append to the PATH environment variable (which already exists) the location where binutils was installed.
Then, configure gcc, build and install it.


Step 8: Build and install libgcc
As a useful addition, you may also like to build libgcc, the GCC low-level runtime library. Linking against libgcc provides integer, floating point, decimal, stack unwinding (useful for exception handling) and other support functions. Once you have built and installed the GCC Cross-Compiler, keep Cygwin opened, and type:

make all-target-libgcc
make install-target-libgcc

Step 9: Edit PATH environment variable
Right click on My Computer, and go to Properties. If you have Windows 7, look for where it says "Computer name". There should be a link there which says Change Settings.
Go to the Advanced tab, and click Environment Variables. Look for the PATH variable, and edit it. Put a semicolon at the end, and add the following path:

[cygwin installation]\usr\local\cross\bin 

(default is C:\cygwin\usr\local\cross\bin)


Step 10: Cleanup
If you renamed any folder at Step 3, you may restore the original name. You can now delete the source code for GCC and binutils, as well as the build-gcc and build-binutils folders.

Troubleshooting: You can visit this link for more information on how to build binutils and GCC, as well as troubleshooting information.


Building our operating system
Now we can go back to our operating system and build it.

Open Cygwin, and create two folders:

mkdir /mnt

mkdir /mnt/floppy

Now edit build.sh:
Add two variables:

compiler=i586-elf-gcc

linker=i586-elf-ld

Now replace gcc and ld, with $compiler, respectively $linker. This way, if somehow the compiler or linker may change, we only have to edit one single line instead of a thousand.

Also, replace all the code that copies kernel.bin to the floppy image, with these two lines:

mount A: /mnt/floppy

cp kernel.bin /mnt/floppy/

You can save and close the file.


The last step is to open the myos.img image, using VFD, and launching the build.
To launch the build, navigate to your work directory (/cygdrive/[drive]/[path]), and execute ./build.sh

OSDEV Series - Episode 1.4 - Windows trouble

Section 1: Introduction
Episode 4: Windows trouble

Project files: http://dl.dropbox.com/u/24832466/OSDEV/MyOS-1.4.zip

Covered topics:
In this episode, we create a proper environment to create operating systems, on Windows.
* Using Virtual Floppy Drive (to replace mount)
* Creating a GRUB floppy image
* Building GCC and Binutils
* Building the kernel created in the previous episode, on a Windows computer.

Special credits:
http://wiki.osdev.org for the building GCC tutorial.