We are working on graphics. We should have them ready in a few days. This might take longer as we don’t have much of a graphics crew, but our guys are the best

Abhishek, can you please monitor the sync of files? And oh yeah, I forgot to add – I am sending the team the graphics vector files. We should be ready to debug them in a few hours.

-Angelina

Rest of the team: password is “testtillyoufest”

Good luck

-Mark (lol, I never thought I’d have to post )

The tech stuff we were waiting for has arrived. Check it out at the Square-M section of the ftp.

Just a reminder: its the prototype of Phoenix-Aura.

-Angelina

-Abhishek

#include “gui/box.h”#include “graphic/surface.h”#include “graphic/colors.h”
Box::Box(const Point2i &size, bool _draw_border) : WidgetList(size){  margin = 5;  border.SetValues(5, 5);
if (_draw_border) {    Widget::SetBorder(defaultOptionColorRect, 2);    Widget::SetBackgroundColor(defaultOptionColorBox);  }}
Box::~Box(){}
void Box::Update(const Point2i &mousePosition, const Point2i &/*lastMousePosition*/){  if (need_redrawing) {    Widget::RedrawBackground(*this);    Draw(mousePosition);  }
WidgetList::Update(mousePosition);  need_redrawing = false;}
// ————————————————–
VBox::VBox(uint width, bool _draw_border, bool _force_widget_size) :  Box(Point2i(width, 100), _draw_border),  force_widget_size(_force_widget_size){}
void VBox::Pack(){  uint _y = position.y;  uint max_size_x = 0;
std::list<Widget *>::iterator it;  for (it = widget_list.begin();       it != widget_list.end();       ++it) {
if (it == widget_list.begin())      _y += border.y – margin;
(*it)->SetPosition(position.x + border.x,       _y + margin);
if (force_widget_size) {      (*it)->SetSize(size.x – 2*border.x,     (*it)->GetSizeY());    } else {      max_size_x = std::max(max_size_x, uint((*it)->GetSizeX()));    }
(*it)->Pack();
_y = (*it)->GetPositionY() + (*it)->GetSizeY();  }
size.y = _y – position.y + border.y;
if (!force_widget_size) {    size.x = max_size_x + 2*border.x;  }}
// ————————————————–
HBox::HBox(uint height, bool _draw_border, bool _force_widget_size) :  Box(Point2i(100, height), _draw_border),  force_widget_size(_force_widget_size){}
void HBox::Pack(){  uint _x = position.x;  uint max_size_y = 0;
std::list<Widget *>::iterator it;  for (it = widget_list.begin();       it != widget_list.end();       ++it) {
if (it == widget_list.begin())      _x += border.x – margin;
(*it)->SetPosition(_x + margin,       position.y + border.y);
if (force_widget_size) {      (*it)->SetSize((*it)->GetSizeX(),     size.y – 2*border.y);    } else {      max_size_y = std::max(max_size_y, uint((*it)->GetSizeY()));    }
(*it)->Pack();
_x = (*it)->GetPositionX()+ (*it)->GetSizeX();  }  size.x = _x – position.x + border.x;
if (!force_widget_size) {    size.y = max_size_y + 2*border.y;  }}
// ————————————————–
GridBox::GridBox(uint _max_line_width, const Point2i& size_of_widget, bool _draw_border) :  Box(Point2i(-1, -1), _draw_border){  max_line_width = _max_line_width;  widget_size = size_of_widget;  last_line = 0;  last_column = 0;}
void GridBox::PlaceWidget(Widget * a_widget, uint _line, uint _column){  uint _x, _y;
_x = position.x + border.x + _column * (widget_size.GetX() + margin);  _y = position.y + border.y + _line * (widget_size.GetY() + margin);
a_widget->SetPosition(_x, _y);  a_widget->SetSize(widget_size);}
uint GridBox::NbWidgetsPerLine(const uint nb_total_widgets){  uint max_nb_widgets_per_line = nb_total_widgets;
while (max_line_width – 2 * border.x < max_nb_widgets_per_line * (widget_size.GetX()+margin) – margin) {    max_nb_widgets_per_line–;  }
if (max_nb_widgets_per_line < 1) {    max_nb_widgets_per_line = 1;  }
uint nb_lines = nb_total_widgets / max_nb_widgets_per_line;  if (nb_total_widgets % max_nb_widgets_per_line != 0) {    nb_lines++;  }
uint nb_widgets_per_line = nb_total_widgets / nb_lines;  if (nb_total_widgets % nb_lines != 0) {    nb_widgets_per_line++;  }
return nb_widgets_per_line;}
void GridBox::Pack(){  WidgetList::Pack();
uint nb_widgets_per_line = NbWidgetsPerLine(widget_list.size());
std::list<Widget *>::iterator it;  uint line = 0, column = 0;  for( it = widget_list.begin();       it != widget_list.end();       ++it ){
last_line = line;    PlaceWidget((*it), line, column);
if (column + 1 == nb_widgets_per_line) {      column = 0;      line++;    } else {      column++;    }
}
size.x = 2*border.x + nb_widgets_per_line * (widget_size.GetX() + margin) – margin;  size.y = 2*border.y + (last_line+1) * (widget_size.GetY() + margin) – margin;
WidgetList::Pack();}

Hope it helps.

-Angelina

Thanks all for your support, we look forward to see you.

The game is initially designed for One Laptop Per Child Foundation’s XO laptop, but work in Linux, Windows and Mac too. But the Windows version will be supported till only ONE(1) year after its release, in due course, other versions will also be released. Linux support is 3 years and Mac version comes with no support as any of us don’t have Apple Macintosh machines.

As the leader of Phoenix-Team, I, Abhishek Indoria, am allowed to give you complete information on the topic:)

“The Game will be released on 31st October, and it will be its initial release, without any warranty. The game can cause harm to systems as it is only an ALPHA Version just now. I only recommend downloading ALPHA V2 after the verification process is completed. However, you can find more information at http://phoenix-team.tk and http://fossfy.co.cc as http://boomingbang.webs.com has been reported malfunctioning on many users’ machines and caused Browser crashes.

The information will be readied within 2 days, and we are hoping to get excellent responses. This version, however, will not be shipped Universally on Disks. This can be downloaded free of cost.

The initial charges of Shipping and Handling will be, as I guess $ 20 , included in which are Tracking and SpeedPost Guarantee of receipt within 10 days.In the normal mail method, however, users would be charged $10 and we take the guarantee of it to be shipped, but NO queries when. It might take 5-7 weeks at maximum.”

The Phoenix-Team currently include 20 members and looking for more. This is an excellent youth group for developing software, and of course, donations are welcome.

As we are developing primarily for OLPC XO laptops, we think that you must be interested in One Laptop Per Child Project.

The One Laptop per Child association develops a low-cost laptop—the “XO Laptop”—to revolutionize how we educate the world’s children. They say that their  mission is “to provide educational opportunities for the world’s poorest children by providing each child with a rugged, low-cost, low-power, connected laptop with content and software designed for collaborative, joyful, self-empowered learning.”

In January 2005 the MIT Media Lab launched a new research initiative to develop a $100 laptop—a technology that could revolutionize how we educate the world’s children. To achieve this goal, a new, non-profit association, One Laptop per Child (OLPC), was created, which is independent of MIT.

The official project website is located at laptop.org. There is also a comprehensive description of the project in Wikipedia.

They say on the OLPC project page :

http://wiki.laptop.org/go/One_Laptop_per_Child

Overview

“One laptop per child” is a concept. It is an education project, not a laptop project. It can be implemented in more than one way, by no means limited to the embodiment of the OLPC non-profit association’s so-called “$100 Laptop.” The argument for olpc is simple: many children—especially those in rural parts of developing countries—have so little access to school—in some cases just a tree—that building schools and training teachers is only one way—perhaps the slowest way—to alleviate the situation. While such building programs and teacher education must not stop, another and parallel method advised by OLPC is to leverage the children themselves by engaging them more directly in their own learning. It may sound implausible to equip the poorest children with connected laptops when rich children may not have them, but it is not. Laptops can be affordable and children are more capable than they are given credit for.

Learning learning

Learning is our main goal; we do not focus on computer literacy, as that is a by-product of the fluency children will gain through use of the laptop for learning. Children—especially young children—do not need to learn about IT and certainly do not need to be fluent users of WORD, EXCEL and POWERPOINT—They are not office workers. However, picking up these skills, having grown up with a laptop, will be readily accomplished.

Learning some math facts while learning to hate math is far from ideal. Learning about things that are personally meaningful while constructing knowledge—especially where children realize that they had to extend themselves beyond what they believed they were capable of doing—is both natural and liberating.

Children need to learn learning, which is primarily acquired through the passion that comes from access, the ability to make things, to communicate and to express. Writing a computer program, while seemingly esoteric, is in fact the closest a child can come to thinking about thinking. Likewise, debugging a program is the closest one can come to learning learning.

It goes without saying that Internet access and tools for expression (text, music, video, graphics) are the contemporary “toys” for learning. Every child of any means in the developed world has access to a computer at home and usually his or her own, with music, DVD, plus interactive and rich media to do anything from learning languages to play games.

Making these same resources available to the roughly one-billion other children, who do not have such access, has seemed ridiculously daunting, but is no longer. This is simply because the high costs of laptops has been artificial and perpetuated, not innate. It is fair to say that OLPC has broken this spell and companies like Intel are following it.

The intransigence of the problems of formal education in the face of conventional solutions, combined with pervasive poverty and the need for high-quality lifelong learning for inclusion in the global knowledge-based economy, warrants new thinking. The same digital technology that has enabled an unparalleled growth of knowledge, when combined with new methodologies for learning, can unleash the latent learning potential of the children of world.

Poor children lack opportunity, not capacity for learning. By providing laptops to every child without cost to the child, we bring the poor child the same opportunities for learning that wealthy families bring to their children.

Scale versus pilot

Consider immunization by analogy. Inoculating a few people here and there has no meaning. Scale is needed. Likewise with laptops. And furthermore, each child has to own his or her own machine and view it not as government property, but as a personal medium, cherished like a bicycle. The child is more confident, has greater self-esteem, and is more entrepreneurial than children without this tool.

Building computer labs in schools was an earlier approach—and perhaps the only one possible in the past. Such labs cater to a formal classroom setting. Today, additional approaches are possible. A laptop program can reach every child within the context of informal settings, which are the only ones available to many children. A nationwide roll out of personal machines can capture many more hours per day than school itself, not to mention night time, weekends and holidays. This will mobilize children. In addition it has significant spill-over effect on the entire family where a child has the OLPC.

Of the many values of scale, the foremost is the child as teacher. Peer-to-peer learning is one of the best ways to leverage children. The reach of such collaboration can go far beyond national borders and, in the longer term, lead to the bigger goals of world peace and understanding. To this end, OLPC is launching on three continents and in at least six countries.

Beyond school

Any parent whose child has a laptop at home has almost undoubtedly asked that child for help. What then follows is a change in one’s relationship with the child, with more elements of friendship and (on the child’s part) self-esteem. This by no means destroys the parent-child relationship. On the contrary, it enhances it. A bond to learning is formed between the child and parent at home.

The teacher-child relationship can and will likewise benefit. With sufficient self-confidence, teachers can learn from children without risk of unraveling the fabric of education—quite the contrary, improving it.

Children must not only own the laptop, but take it home. In so doing the whole family will benefit. Current pilot projects have shown unequivocally that parents become more engaged in their child’s learning and, very often, learn to use the laptops themselves. The role of the child in society changes; it is a more productive role. The child is not the object of change but the agent of change.

Features

Children need more—not fewer—features than high-end laptops. Notably, they need three things unique to their condition: low power, sunlight readability, and automatic connectivity.

Low power is key. Most children do not have electricity at home. Therefore, a laptop needs to run on both human power and long-life batteries. Human power, whether cranking or other gestures, must run a laptop at least 1-to-10: one minute of cranking provides ten minutes of use. In the case of batteries, a 10-hour life is need. Laptops cannot be plugged in at desks in classrooms. Even the richest school does not provide power to each desk.

Sunlight-readable displays are important for outdoor use as well as power conservation. This should be achieved as an option to traditional backlighting, not as a replacement to it. Both are needed. Furthermore, during night-time use, the laptop itself needs to be the light source for the surrounding area.

Connectivity cannot assume DSL, WiFi hotspots, or the like. Instead, the laptops collectively have to make a network automatically, without child or teacher intervention. Roughly 500 children should be able to share a single point of back haul to the Internet. While this may be modest bandwidth, among themselves and with a school server they must have very broadband connections.

A further goal of the OLPC effort is to awaken the software and hardware giants to the needs of children in the developing world and thus to reconsider their strategies.

—

Good luck with OLPC, and thanks to the team for providing the info

What is Aura?

Aura is a free and open source Operating System designed for primarily low cost… and sub-standard netbooks like OLPC XO-1.5 or probably XO and Asus EEEPC. Of course, Aura’s advanced version, Aura-X will be available for Home PCs and Notebook computers as well as servers.

Phoenix-Team is intending to start the development of Aura from October 2009. Aura is based on OpenSuse 11.1 Platform and  Phoenix Aura-X is based on Suse platform. Aura will be free including updates and enterprise editions. It is based on 3 systems: GNOME, KDE and XFce.

Why Aura?

These days, many low cost, low powered netbooks are being introduced. These are great for students, travelers and teachers. Aura is introduced to design in such a way that it would not only provide all essential services like surfing the web, chatting, emailing, creating office documents, spreadsheets, presentations, managing your inventor, playing games, designing your own software or server management … but It would be fast and compact… Extremely fast than current time Linux Operating systems.

Other proprietary Operating systems(Mac OS, Microsoft Windows) are now days…somewhat fading away and software developers consider to use Linux in place of these Operating Systems.Aura is great for developers along with youth and children who are willing to learn something and for students who are thinking to buy a netbook and who go to school or universities.

Stay Connected…Always

Phoenix Aura introduces a new and extremely fast way to stay connected to web…your friends, colleagues  with up-to-date web browsers. updates and plug-ins along with Phoenix-Team’s featured web browser EasyWeb. Aura provides fast connectivity, excellent speed and downloading…all free of cost.

Developing…NO problems

Software development in Aura is easy and fast…Several tools can be found pre-installed on Phoenix Aura and more on Phoenix Aura-X. Other tools are available via update. Aura will be a hub for software developers in very near future, we expect. Aura comes pre-installed with many development languages IDE, popular in which are Python,C, NetBeans, Java and so on… Aura gives you complete flexibility of what to develop, when to develop and how to develop.

Save up Space…

With Phoenix Aura, you will be able to manage your hard disk space and RAM usage. While Phoenix Aura installs just within 1.4 GB of space and Phoenix Aura-X within 4 GB…It gives freedom to users to install various software, regardless of their size, with a fast speed.

Freedom is necessary…

Phoenix-Team believes in freedom and believes that access to free software should be everyone’s right. We are currently working to achieve this target and we will, with your help, very soon find this target too…

Get best software in Aura

While using Aura, you will get access to thousands of free software around the world, all with best documention and  you will find every…every alternative to a Windows or Mac OS software like OpenOffice.Org for Microsoft Office, Mozilla Firefox and Phoenix EasyWeb for Internet explorer and many games,programming IDEs, plug-ins and server and database tools too…

We hope you liked the introduction to Aura…We are hoping to see it installed in your PC soon too.

The deadline is set as January 2010. Maybe we can do a little bit more developing after that

-A

TODO: Please mail me for the source code!