static void
cheese_avatar_widget_init (CheeseAvatarWidget *widget)
{
CheeseAvatarWidgetPrivate *priv;
GtkWidget *frame;
GtkWidget *image;
priv = cheese_avatar_widget_get_instance_private (widget);
priv->flash = cheese_flash_new (GTK_WIDGET (widget));
priv->notebook = gtk_notebook_new ();
g_object_set(G_OBJECT (priv->notebook), "margin", 12, NULL);
gtk_notebook_set_show_border (GTK_NOTEBOOK (priv->notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (priv->notebook), FALSE);
gtk_container_add (GTK_CONTAINER (widget), priv->notebook);
/* Camera tab */
priv->camera = cheese_widget_new ();
g_signal_connect (G_OBJECT (priv->camera), "notify::state",
G_CALLBACK (state_change_cb), widget);
image = gtk_image_new_from_icon_name ("camera-photo-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
priv->take_button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (priv->take_button), image);
g_signal_connect (G_OBJECT (priv->take_button), "clicked",
G_CALLBACK (take_button_clicked_cb), widget);
gtk_widget_set_sensitive (priv->take_button, FALSE);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
create_page (priv->camera, priv->take_button),
gtk_label_new ("webcam"));
/* Image tab */
priv->image = um_crop_area_new ();
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (frame), priv->image);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
priv->take_again_button = gtk_button_new_with_mnemonic (_("_Take Another Picture"));
g_signal_connect (G_OBJECT (priv->take_again_button), "clicked",
G_CALLBACK (take_again_button_clicked_cb), widget);
gtk_widget_set_sensitive (priv->take_again_button, FALSE);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
create_page (frame, priv->take_again_button),
gtk_label_new ("image"));
priv->sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget (priv->sizegroup, priv->take_button);
gtk_size_group_add_widget (priv->sizegroup, priv->take_again_button);
gtk_widget_show_all (GTK_WIDGET (widget));
}
void testMultithreaded(){
int NUMTHREADS = 2;
pthread_t threads[NUMTHREADS];
vAddr indexes[100];
int i;
// indexes
for (i = 0; i < 100; ++i) {
if (DEBUG)
printf("Page %d is being created\n",i);
indexes[i] = create_page();
uint32_t *val = get_value(indexes[i]);
if (val){
uint32_t myrand = (*val + rand()) %1000+1000;
store_value(indexes[i], &myrand);
}
}
// threads
for (i=0; i<NUMTHREADS; i++){
uint32_t *thread_id = malloc(sizeof(int));
*thread_id = i;
pthread_create (&(threads[i]),NULL, (void *) &multithreadedHelper, thread_id);
}
for (i=0; i<NUMTHREADS; i++){
pthread_join (threads[i], NULL);
}
}
static void
ditem_read_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GnomeDesktopItem *item;
GtkWidget *box;
gsize file_size;
char *file_contents;
box = GTK_WIDGET (user_data);
if (g_file_load_contents_finish (G_FILE (source_object),
res,
&file_contents, &file_size,
NULL, NULL)) {
item = gnome_desktop_item_new_from_string (g_object_get_data (G_OBJECT (box),
"uri"),
file_contents,
file_size,
0, NULL);
g_free (file_contents);
if (item == NULL) {
return;
}
/* for some reason, this isn't done automatically */
gnome_desktop_item_set_location (item, g_object_get_data (G_OBJECT (box), "uri"));
create_page (item, box);
gnome_desktop_item_unref (item);
}
g_object_unref (box);
}
static void
ditem_read_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GKeyFile *key_file;
GtkWidget *box;
gsize file_size;
char *file_contents;
box = GTK_WIDGET (user_data);
if (g_file_load_contents_finish (G_FILE (source_object),
res,
&file_contents, &file_size,
NULL, NULL))
{
key_file = g_key_file_new ();
g_object_set_data_full (G_OBJECT (box), "keyfile", key_file, (GDestroyNotify)g_key_file_free);
if (g_key_file_load_from_data (key_file, file_contents, file_size, 0, NULL))
{
create_page (key_file, box);
}
g_free (file_contents);
}
g_object_unref (box);
}
static int add_new_page_normal_style (HWND hwnd, PCONTROL ctrl, PPROPSHEETDATA propsheet,
DLGTEMPLATE *dlg, WNDPROC proc)
{
PPROPPAGE page;
int index;
if (!(page = calloc (1, sizeof (PROPPAGE)))) {
return PS_ERR;
}
if (!create_page (hwnd, ctrl->dwStyle, propsheet, page, dlg, proc)) {
free (page);
return PS_ERR;
}
index = insert_new_page_normal_style (hwnd, propsheet,
page, ctrl->dwStyle);
NotifyParent (hwnd, ctrl->id, PSN_ACTIVE_CHANGED);
show_hide_page (page, SW_SHOW);
InvalidateRect (hwnd, &propsheet->head_rc, TRUE);
/* dump_propsheetdata (propsheet); */
return index;
}
void bin_index_t::file_node::add_item(const index_t& val,page_t& page)
{
page_pr pr(page);
page_iter p=std::lower_bound(page.begin(),page.end(),val.key,pr);
index_ref r=page[static_cast<size_t>(*p)];
if(r.left()==0)
{
index_t cp(val);
cp.index_in_page=static_cast<size_t>(*p);
page.insert_item(cp);
return;
}
page_ptr child_page=get_page(r.left());
if(child_page->items_count()<child_page->page_max)
{
add_item(val,*child_page);
return;
}
page_ptr new_right_page(create_page());
split_page(*child_page,page,static_cast<size_t>(*p),*new_right_page);
if(pr(val.key,*p)) add_item(val,*child_page);
else add_item(val,*new_right_page);
add_page(new_right_page);
}
void*
kma_malloc(kma_size_t size)
{
kma_size_t total_size;
/* If first malloc, initialize necessary information */
if (root_page == NULL) {
root_page = get_page();
/* Figure out how many size classes there should be */
kma_size_t class_size = PAGESIZE;
int num_classes = 0;
while (class_size >= FREE_HEADER_SIZE) {
FIRST_FREE_NODE(num_classes) = NULL;
MASK(num_classes) = NULL;
MASK(num_classes) += class_size;
num_classes++;
class_size >>= 1;
}
kma_size_t control_block_size = 0x1;
while (control_block_size < num_classes * sizeof(void*) ||
control_block_size < ALLOC_HEADER_SIZE) {
control_block_size <<= 1;
}
total_size = control_block_size;
while (total_size < PAGESIZE) {
create_page(root_page->ptr + total_size, total_size);
total_size <<= 1;
}
}
static void
gdm_ovirtcred_extension_init (GdmOVirtCredExtension *extension)
{
extension->priv = G_TYPE_INSTANCE_GET_PRIVATE (extension,
GDM_TYPE_OVIRTCRED_EXTENSION,
GdmOVirtCredExtensionPrivate);
extension->priv->icon = g_themed_icon_new ("gdm-ovirtcred");
create_page (extension);
create_actions (extension);
gdm_ovirtcred_extension_reset (GDM_CONVERSATION (extension));
}
void memoryTester() {
vAddr indexes[1000];
uint32_t i = 0;
for( ; i < 1000; i++ )
indexes[i] = create_page();
for( i = 0; i < 1000; ++i ) {
uint32_t value = i;
store_value(indexes[i], &value);
}
for( i = 0; i < 1000; i++ )
free_page(indexes[i]);
}
/**
* testFullMemory()
* This function tries to add more than 1000 pages, and shows failure to do so
*/
void testFullMemory(){
printf("\n------------------------------\nTest testFullMemory()...\n");
vAddr indexes[1015];
int i;
for (i = 0; i < 1000; i++){
indexes[i] = create_page();
uint32_t *value = get_value(indexes[i]);
*value = (i * 3);
store_value (indexes[i], value);
}
for (i = 0; i < 1000; i++){
indexes[i] = create_page();
// this should fail, and return -1
if (indexes[i] == -1){
//printf(" Failed to allocate new page in memory. 1000 pages already in memory. \n");
}
}
printf("\n------------------------------\nTest testFullMemory() SUCCESS!\n");
}
void memoryMaxer() {
vAddr indexes[1000];
int i = 0;
for (i = 0; i < 128; ++i) {
indexes[i] = create_page();
int *value = get_value(indexes[i]);
*value = (i * 3);
store_value(indexes[i], value);
}
for (i = 0; i < 128; ++i) {
free_page(indexes[i]);
}
}
hash_table* hash_createtable(size_t length, size_t maxentries)
{
hash_table* t = (hash_table*)malloc(sizeof(hash_table));
size_t i;
t->size = length;
t->buf = (hash_entry**)malloc(sizeof(hash_entry*) * length);
t->p = create_page(sizeof(hash_entry), maxentries);
for (i = 0; i < length; i++) {
t->buf[i] = NULL;
}
return t;
}
static void
create_summary_page (AssistantWindow *assistant)
{
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *sw;
GtkWidget *tree;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
vbox = create_page (assistant, _("Configuration Complete"), GTK_ASSISTANT_PAGE_CONFIRM);
label = gtk_label_new (_("You have now finished the Ekiga configuration. All "
"the settings can be changed in the Ekiga preferences. "
"Enjoy!"));
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
label = gtk_label_new (_("Configuration summary:"));
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
assistant->priv->summary_model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
tree = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (tree),
GTK_TREE_MODEL (assistant->priv->summary_model));
gtk_container_add (GTK_CONTAINER (sw), tree);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Option", cell,
"text", SUMMARY_KEY_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Value", cell,
"text", SUMMARY_VALUE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
assistant->priv->summary_page = vbox;
gtk_widget_show_all (vbox);
}
// Testing functions and some helper functions
void memoryMaxer() {
vAddr indexes[1000];
uint32_t i = 0;
for ( ; i < 1000; ++i) {
indexes[i] = create_page();
int valid = 0;
uint32_t value = get_value(indexes[i], &valid);
if(!valid) return; // Address not found
value = (i * 3);
store_value(indexes[i], &value);
}
for (i = 0; i < 1000; ++i) {
free_page(indexes[i]);
}
}
/**
* Test function. Used in a multithreaded manner during stress testing.
*/
void memoryMaxer(){
printf("\n------------------------------\nTest memoryMaxer()...\n");
vAddr indexes[1000];
int i;
for (i = 0; i < 1000; i++){
indexes[i] = create_page();
uint32_t *value = get_value(indexes[i]);
*value = (i * 3);
store_value (indexes[i], value);
}
for (i = 0; i < 1000; i++){
free_page(indexes[i]);
}
printf("\n------------------------------\nTest memoryMaxer() SUCCESS!\n");
}
static void
gdm_password_extension_init (GdmPasswordExtension *extension)
{
extension->priv = G_TYPE_INSTANCE_GET_PRIVATE (extension,
GDM_TYPE_PASSWORD_EXTENSION,
GdmPasswordExtensionPrivate);
extension->priv->icon = g_themed_icon_new ("dialog-password");
create_page (extension);
create_actions (extension);
extension->priv->message_queue = g_queue_new ();
gdm_password_extension_reset (GDM_LOGIN_EXTENSION (extension));
}
/**
* testRAM();
* This function puts everything into RAM and then successfully takes it out.
*/
void testRAM(){
printf("\n------------------------------\nTest testRAM()...\n");
vAddr indexes[10];
int i;
for (i = 0; i < 10; i++){
indexes[i] = create_page();
uint32_t *val = get_value(indexes[i]);
*val = (i * 3);
store_value (indexes[i], val);
}
for (i = 0; i < 10; i++){
free_page(indexes[i]);
}
printf("\n------------------------------\nTest testRAM() SUCCESS!\n");
}
int main(int argc, char const *argv[])
{
int i,j,initValues[NUMTHREADPAGES],returnValues[NUMTHREADPAGES];
struct timeval start_time, end_time;
gettimeofday(&start_time, NULL);
//create
for (i = 0; i < NUMTHREADPAGES; ++i) {
memory[i] = create_page();
}
printf("%d %d\n", memory[10], memory[100]);
//store
for (i = 0; i < NUMTHREADPAGES; ++i) {
j = i*3;
store_value(memory[i], &j);
initValues[i]=j;
}
//get
for (i = 0; i < NUMTHREADPAGES; ++i) {
j= *get_value(memory[i]);
if(j != initValues[i])
printf("ErrorInMemory! expected: %d, actual: %d\n", initValues[i],j);
}
//free
for (i = 0; i < NUMTHREADPAGES; ++i) {
free_page(memory[i]);
}
gettimeofday(&end_time, NULL);
double msec = (end_time.tv_sec - start_time.tv_sec) * 1000 +
(end_time.tv_usec - start_time.tv_usec) / 1000.;
printf("Thread: %d time = %f\n", 1, msec);
}
void create_cluster(){
int n,i=0;
printf("\nEnter the number of cluster want to create: ");
scanf("%d",&num_of_clusters);
n=num_of_clusters;
cnode=calloc(n,sizeof(struct cluster));
while(n>0)
{
printf("\nEnter the cluster name:");
scanf("%s",(cnode+i)->cname);
create_page(cnode+i);
(cnode+i)->nextcluster=(cnode+i)+1;
n--;
i++;
}
}
static void
gdm_smartcard_extension_init (GdmSmartcardExtension *extension)
{
extension->priv = G_TYPE_INSTANCE_GET_PRIVATE (extension,
GDM_TYPE_SMARTCARD_EXTENSION,
GdmSmartcardExtensionPrivate);
extension->priv->icon = g_themed_icon_new ("gdm-smartcard");
create_page (extension);
create_actions (extension);
extension->priv->message_queue = g_queue_new ();
extension->priv->settings = g_settings_new ("org.gnome.login-screen");
gdm_smartcard_extension_reset (GDM_LOGIN_EXTENSION (extension));
}
//---------------------------------------------------------------------------
IMPLEMENTATION [arm]:
#include "mem_unit.h"
#include "kmem_space.h"
#include "paging.h"
#include <cassert>
IMPLEMENT inline
Mword Kmem::is_kmem_page_fault(Mword pfa, Mword)
{
return in_kernel(pfa);
}
IMPLEMENT inline
Mword Kmem::is_io_bitmap_page_fault(Mword)
{
return 0;
}
PUBLIC static
Address
Kmem::mmio_remap(Address phys)
{
static Address ndev = 0;
Address v = phys_to_pmem(phys);
if (v != ~0UL)
return v;
Address dm = Mem_layout::Registers_map_start + ndev;
assert(dm < Mem_layout::Registers_map_end);
ndev += Config::SUPERPAGE_SIZE;
auto m = Kmem_space::kdir()->walk(Virt_addr(dm), Pte_ptr::Super_level);
assert (!m.is_valid());
assert (m.page_order() == Config::SUPERPAGE_SHIFT);
Address phys_page = cxx::mask_lsb(phys, Config::SUPERPAGE_SHIFT);
m.create_page(Phys_mem_addr(phys_page), Page::Attr(Page::Rights::RWX(), Page::Type::Uncached(),
Page::Kern::Global()));
m.write_back_if(true, Mem_unit::Asid_kernel);
add_pmem(phys_page, dm, Config::SUPERPAGE_SIZE);
return phys_to_pmem(phys);
}
static void
gdm_fingerprint_extension_init (GdmFingerprintExtension *extension)
{
extension->priv = G_TYPE_INSTANCE_GET_PRIVATE (extension,
GDM_TYPE_FINGERPRINT_EXTENSION,
GdmFingerprintExtensionPrivate);
extension->priv->icon = g_themed_icon_new ("gdm-fingerprint");
create_page (extension);
create_actions (extension);
extension->priv->message_queue = g_queue_new ();
extension->priv->settings = g_settings_new ("org.gnome.login-screen");
extension->priv->bus_connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
gdm_fingerprint_extension_reset (GDM_LOGIN_EXTENSION (extension));
}
bool bin_index_t::file_node::set(const data_t& key,const data_t& val)
{
validate_key_len(key);
open_index_file();
if(!root_page)
{
root_page=create_page();
append_page(*root_page);
save_index_data(0,root_page->page_offset);
add_page(root_page);
}
index_t it;
align_key(key,it);
if(get_item(it))
{
index_t old_i=it;
if(it.data_len>=val.size())save_data(it.data_offset,val);
else it.data_offset=append_data(val);
it.data_len=val.size();
if(old_i.data_offset==it.data_offset&&
old_i.data_len==it.data_len)
return false;
update_page(it);
return false;
}
index_t v;
v.key=key;
align_key(key,v);
v.data_len=val.size();
v.data_offset=append_data(val);
add_item(v);
return true;
}
void bin_index_t::file_node::add_item(const index_t& val)
{
if(root_page->items_count()<root_page->page_max)
{
add_item(val,*root_page);
return;
}
page_ptr new_root(create_page());
index_ref r=(*new_root)[0];
r.left()=root_page->page_offset;
add_item(val,*new_root);
root_page=new_root;
append_page(*new_root);
add_page(root_page);
save_index_data(0,new_root->page_offset);
}
PUBLIC
Mem_space::Status
Vm_vmx_ept::v_insert(Mem_space::Phys_addr phys, Mem_space::Vaddr virt,
Mem_space::Page_order size, Mem_space::Attr page_attribs)
{
// insert page into page table
// XXX should modify page table using compare-and-swap
assert (cxx::get_lsb(Mem_space::Phys_addr(phys), size) == 0);
assert (cxx::get_lsb(Virt_addr(virt), size) == 0);
int level;
for (level = 0; level <= Ept::Depth; ++level)
if (Mem_space::Page_order(Ept::page_order_for_level(level)) <= size)
break;
auto i = _ept->walk(virt, level, false,
Kmem_alloc::q_allocator(ram_quota()));
if (EXPECT_FALSE(!i.is_valid() && i.level != level))
return Mem_space::Insert_err_nomem;
if (EXPECT_FALSE(i.is_valid()
&& (i.level != level || Mem_space::Phys_addr(i.page_addr()) != phys)))
return Mem_space::Insert_err_exists;
if (i.is_valid())
{
if (EXPECT_FALSE(!i.add_attribs(page_attribs)))
return Mem_space::Insert_warn_exists;
return Mem_space::Insert_warn_attrib_upgrade;
}
else
{
i.create_page(phys, page_attribs);
return Mem_space::Insert_ok;
}
}
void bin_index_t::file_node::validate_root_offset() const
{
root_page.reset();
file_offset_t sz=fi->get_size();
if(sz==0)
{
data_t d(parent.page_max_size,0);
const_cast<file_node*>(this)->save_index_data(0,d);
return;
}
data_t d(sizeof(file_offset_t));
load_index_data(0,d);
page_ptr p(create_page());
p->page_offset=*reinterpret_cast<const file_offset_t*>(&d[0]);
load_page(*p);
const_cast<file_node*>(this)->add_page(p);
root_page=p;
}
void memoryTester() {
vAddr indexes[1000];
uint32_t i = 0;
for( ; i < 1000; i++ )
indexes[i] = create_page();
for( i = 0; i < 1000; ++i ) {
uint32_t value = i;
store_value(indexes[i], &value);
}
for( i = 0; i < 1000; i++ ) {
uint32_t expectedValue = i;
int valid = 0;
uint32_t value = get_value(indexes[i], &valid);
if(!valid) return; // Address not found
if(value != expectedValue) {
printf("Failure to prove correctness of the algorithm! Exitting...\n");
exit(1);
}
}
for( i = 0; i < 1000; i++ )
free_page(indexes[i]);
}
bin_index_t::page_ptr bin_index_t::file_node::get_page(file_offset_t page_offset)
{
pages_t::iterator it=pages.find(page_offset);
if(it!=pages.end())
{
page_ptr p=it->second;
if(!p->left.expired())
{
remove_from_list(p);
insert_into_list(p,first_page.lock());
}
return p;
}
page_ptr p(create_page());
p->self=p;
p->page_offset=page_offset;
load_page(*p);
add_page(p);
return p;
}
int main(int argc, char **argv)
{
GtkWidget *menubar = NULL;
GtkWidget *table = NULL;
GtkWidget *combo = NULL;
GtkBin *bin = NULL;
GtkViewport *view = NULL;
int i=0;
log_options_t lopts = LOG_OPTS_STDERR_ONLY;
if (!getenv("SLURM_BITSTR_LEN"))
setenv("SLURM_BITSTR_LEN", "128", 1); /* More array info */
slurm_conf_init(NULL);
log_init(argv[0], lopts, SYSLOG_FACILITY_USER, NULL);
load_defaults();
cluster_flags = slurmdb_setup_cluster_flags();
cluster_dims = slurmdb_setup_cluster_dims();
_init_pages();
sview_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
/* Initialize GTK */
gtk_init (&argc, &argv);
sview_mutex_new(&sview_mutex);
sview_mutex_new(&grid_mutex);
sview_cond_new(&grid_cond);
/* make sure the system is up */
grid_window = GTK_WIDGET(create_scrolled_window());
bin = GTK_BIN(>K_SCROLLED_WINDOW(grid_window)->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
main_grid_table = GTK_TABLE(bin->child);
gtk_table_set_homogeneous(main_grid_table, true);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(grid_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
/* fill in all static info for pages */
/* Make a window */
main_window = gtk_dialog_new();
g_signal_connect(G_OBJECT(main_window), "delete_event",
G_CALLBACK(_delete), NULL);
gtk_window_set_title(GTK_WINDOW(main_window), "Sview");
gtk_window_set_default_size(GTK_WINDOW(main_window),
working_sview_config.main_width,
working_sview_config.main_height);
gtk_container_set_border_width(
GTK_CONTAINER(GTK_DIALOG(main_window)->vbox), 1);
/* Create the main notebook, place the position of the tabs */
main_notebook = gtk_notebook_new();
g_signal_connect(G_OBJECT(main_notebook), "switch_page",
G_CALLBACK(_page_switched),
NULL);
table = gtk_table_new(1, 3, false);
gtk_table_set_homogeneous(GTK_TABLE(table), false);
gtk_container_set_border_width(GTK_CONTAINER(table), 1);
/* Create a menu */
menubar = _get_menubar_menu(main_window, main_notebook);
gtk_table_attach_defaults(GTK_TABLE(table), menubar, 0, 1, 0, 1);
if ((combo = _create_cluster_combo())) {
GtkWidget *label = gtk_label_new("Cluster ");
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
gtk_table_attach(GTK_TABLE(table), combo, 2, 3, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
}
gtk_notebook_popup_enable(GTK_NOTEBOOK(main_notebook));
gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_notebook), true);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_notebook),
working_sview_config.tab_pos);
main_statusbar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(main_statusbar),
false);
/* Pack it all together */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, false, false, 0);
table = gtk_table_new(1, 2, false);
gtk_table_attach(GTK_TABLE(table), grid_window, 0, 1, 0, 1,
GTK_SHRINK, GTK_EXPAND | GTK_FILL,
0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), main_notebook, 1, 2, 0, 1);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, true, true, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
main_statusbar, false, false, 0);
in_process_cursor = gdk_cursor_new(GDK_WATCH);
for(i=0; i<PAGE_CNT; i++) {
if (main_display_data[i].id == -1)
break;
create_page(GTK_NOTEBOOK(main_notebook),
&main_display_data[i]);
}
/* tell signal we are done adding */
popup_list = list_create(destroy_popup_info);
signal_params_list = list_create(destroy_signal_params);
gtk_widget_show_all(main_window);
adding = 0;
/* apply default settings */
if (!working_sview_config.show_grid)
gtk_widget_hide(grid_window);
for(i=0; i<PAGE_CNT; i++) {
GtkWidget *visible_tab = NULL;
if (main_display_data[i].id == -1)
break;
visible_tab = gtk_notebook_get_nth_page(
GTK_NOTEBOOK(main_notebook), i);
if (working_sview_config.page_visible[i]
|| (i == working_sview_config.default_page)
|| (i == TAB_PAGE))
gtk_widget_show(visible_tab);
else
gtk_widget_hide(visible_tab);
}
/* Set the default page. This has to be done after the
* gtk_widget_show_all since it, for some reason always sets
* 0 to be the default page and will just overwrite this. */
/* Also if we already are set at the current page we need to
start up the page thread, so just call the _page_switched
function. If we aren't already there, then set the current
page which will inturn call the _page_switched. If the
pages is already this the signal doesn't happen so handle
it here.
*/
if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_notebook))
== working_sview_config.default_page)
_page_switched(GTK_NOTEBOOK(main_notebook), NULL,
working_sview_config.default_page, NULL);
else
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_notebook),
working_sview_config.
default_page);
/* Finished! */
gtk_main ();
gdk_threads_leave();
return 0;
}
static int
traverse(const char *path, const struct stat *s, int flag)
{
int ret = 0;
char *path_no_ext = NULL;
FILE *out = NULL;
char *out_path = NULL;
char *header = NULL;
size_t header_len;
char *footer = NULL;
size_t footer_len;
char *sed_args[16] = {NULL};
struct page *page = NULL;
const char *date_ext = path;
while ((date_ext = strstr(date_ext, ".date")) != NULL) {
if (*(date_ext + sizeof(".date") - 1) == '\0') {
return 0;
}
}
/* Strip the first part of the path to get the HTTP path */
path += sizeof("./src") - 1;
if (path[0] == '\0') return 0;
++path;
if (S_ISDIR(s->st_mode)) {
puts(path);
xasprintf(&out_path, "./build/%s", path);
if (mkdir(out_path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) == -1) {
if (errno != EEXIST) {
perror("mkdir");
goto error;
}
}
} else {
time_t secs = time(NULL);
struct tm now;
if (gmtime_r(&secs, &now) == NULL) {
perror("gmtime_r");
goto error;
}
if ((page = create_page(path, s)) == NULL) {
goto error;
}
path_no_ext = strip_extension(xstrdup(path));
xasprintf(&out_path, "./build/%s.html", path_no_ext);
page->htpath = xstrdup(out_path + sizeof("./build") - 1);
printf("%s -> %s (%s)\n", path, page->title, out_path);
/* Make header */
sed_args[0] = xstrdup("sed");
xasprintf(&sed_args[1], "-e s|${base_url}|%s|g",
x.base_url);
xasprintf(&sed_args[2], "-e s|${year}|%d|g",
now.tm_year + 1900);
xasprintf(&sed_args[3], "-e s|${created}|%s|g",
page->created_iso);
xasprintf(&sed_args[4], "-e s|${created_readable}|%s|g",
page->created_readable);
xasprintf(&sed_args[5], "-e s|${modified}|%s|g",
page->modified_iso);
xasprintf(&sed_args[6], "-e s|${modified_readable}|%s|g",
page->modified_readable);
xasprintf(&sed_args[7], "-e s|${owner}|%s|g", page->user);
xasprintf(&sed_args[8], "-e s|${title}|%s|g", page->title);
sed_args[9] = xstrdup("header.html");
if ((header = read_pipe(sed_args, &header_len)) == NULL) {
goto error;
}
free(sed_args[9]);
sed_args[9] = xstrdup("footer.html");
if ((footer = read_pipe(sed_args, &footer_len)) == NULL) {
goto error;
}
out = fopen(out_path, "w");
if (out == NULL) {
perror("fopen");
goto error;
}
if (fwrite(header, 1, header_len, out) < header_len) {
perror("fwrite");
goto error;
}
if (fwrite(page->body, 1, page->body_len, out) < page->body_len) {
perror("fwrite");
goto error;
}
if (fwrite(footer, 1, footer_len, out) < footer_len) {
perror("fwrite");
goto error;
}
}
end:
if (out != NULL) {
fclose(out);
}
free(out_path);
free(header);
free(footer);
free(path_no_ext);
for (size_t i = 0; i < (sizeof(sed_args) / sizeof(char *)); ++i) {
free(sed_args[i]);
}
return ret;
error:
ret = -1;
goto end;
}
