MainWindow::MainWindow(std::shared_ptr<ChartModel> chart_model)
: menu_file(nullptr)
, menu_view(nullptr)
, menu_help(nullptr)
, toolbar(nullptr)
, action_exit(nullptr)
, action_toggle_fullscreen(nullptr)
, action_about(nullptr)
, action_about_qt(nullptr)
, action_zoom_in(nullptr)
, action_zoom_out(nullptr)
, map_widget(nullptr)
, chart_model(chart_model)
{
setWindowTitle(tr("qtnavigator"));
map_widget = new MapWidget(this);
map_widget->set(chart_model);
create_actions();
create_menus();
create_statusbar();
create_toolbar();
setCentralWidget(map_widget);
}
void loadEveBrowser()
{
int argc = 0;
printf("%s:%d\n", __func__, __LINE__);
gtk_init_check(&argc, NULL);
if (!g_thread_supported ())
g_thread_init (NULL);
printf("%s:%d\n", __func__, __LINE__);
GtkWidget* fixed = gtk_fixed_new();
g_vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), create_toolbar (), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), GTK_WIDGET (create_browser ()), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), create_statusbar (), FALSE, FALSE, 0);
g_window = create_window ();
gtk_fixed_put(GTK_FIXED(fixed), g_vbox, 0, 0);
gtk_widget_set_size_request(g_vbox, g_framebuffer_width, g_framebuffer_height);
GtkWidget* statusLabel = gtk_label_new ("Status");
gtk_fixed_put(GTK_FIXED(fixed), statusLabel, g_framebuffer_width - 200, 0);
gtk_widget_set_size_request(statusLabel, 200, 100);
gtk_container_add (GTK_CONTAINER (g_window), fixed);
}
static bool
view6_load_cb(ui_standard_view *view, void *data)
{
Evas_Object *content = NULL;
Evas_Object *base = NULL;
//Get a base object from view.
base = ui_view_get_base(view);
if (!base)
{
dlog_print(DLOG_ERROR, LOG_TAG, "failed to get a view base object");
return false;
}
//Create and set a main content.
content = create_content(base, "ViewMgr Demo<br>Toolbar", prev_btn_clicked_cb, next_btn_clicked_cb);
if (!content) return false;
Elm_Toolbar *toolbar = create_toolbar(base, "toolbar_with_title");
if (!toolbar) return false;
if (!ui_view_set_content(view, content) ||
!ui_standard_view_set_title(view, "Page6") ||
!ui_standard_view_set_toolbar(view, toolbar))
{
dlog_print(DLOG_ERROR, LOG_TAG, "failed to set view property");
return false;
}
return true;
}
wxraytracerFrame::wxraytracerFrame(const wxPoint& pos, const wxSize& size)
: wxFrame((wxFrame *)NULL, -1, wxT( "Ray Tracer" ), pos, size) {
wxMenu* menuFile = new wxMenu;
menuFile->Append(Menu_File_Open, wxT("&Open..." ));
menuFile->Append(Menu_File_Save, wxT("&Save As..."));
menuFile->AppendSeparator();
menuFile->Append(Menu_File_Quit, wxT("E&xit"));
menuFile->Enable(menuFile->FindItem(wxT("&Save As...")), FALSE);
wxMenuBar* menuBar = new wxMenuBar;
menuBar->Append(menuFile, wxT("&File" ));
menuDebug_ = new wxMenu;
menuDebug_->AppendCheckItem(Menu_Debug_Sampler, wxT("Shader"));
menuBar->Append(menuDebug_, wxT("&Debug" ));
SetMenuBar( menuBar );
create_toolbar();
canvas = new RenderCanvas(this);
CreateStatusBar();
SetStatusText(wxT("Ready"));
wxIcon icon(main_xpm);
SetIcon(icon);
wxStatusBar* statusBar = GetStatusBar();
int widths[] = {150,300};
statusBar->SetFieldsCount(2, widths);
}
/**
* \brief Default constructor.
* \param env The workspace environment.
*/
bf::main_frame::main_frame( const workspace_environment& env )
: wxFrame(NULL, wxID_ANY, wxT("Bear Factory - Animation editor")),
m_workspace(env)
{
create_menu();
create_toolbar();
create_controls();
Fit();
} // main_frame::main_frame()
MainWindow::MainWindow()
{
init();
create_toolbar();
create_mainWidget();
create_action();
qDebug() << QSqlDatabase::drivers() << endl;
db_connect();
setWindowTitle(codec->toUnicode("주소관리"));
}
void *GtkMain(void * argument)
{
printf("%s:%d\n", __func__, __LINE__);
int argc = 0;
char**argv = NULL;
unsigned char haveUrl = 0;
int argCount = 0;
gtk_init (&argc, &argv);
if (!g_thread_supported ())
g_thread_init (NULL);
GtkWidget* fixed = gtk_fixed_new();
//screen_changed(fixed, NULL, NULL);
g_vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), create_toolbar (), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), GTK_WIDGET (create_browser ()), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), create_statusbar (), FALSE, FALSE, 0);
g_window = create_window ();
gtk_fixed_put(GTK_FIXED(fixed), g_vbox, 0, 0);
gtk_widget_set_size_request(g_vbox, g_framebuffer_width, g_framebuffer_height);
GtkWidget* statusLabel = gtk_label_new ("Status");
gtk_fixed_put(GTK_FIXED(fixed), statusLabel, g_framebuffer_width - 200, 0);
gtk_widget_set_size_request(statusLabel, 200, 100);
gtk_container_add (GTK_CONTAINER (g_window), fixed);
webkit_web_view_load_uri (g_web_view, g_url);
gtk_widget_grab_focus (GTK_WIDGET (g_web_view));
gtk_widget_show_all (g_window);
toogleMode();
g_default_scale = g_framebuffer_width / 1280.0f;
handleZoomLock(0);
g_Callback(1);
gtk_main ();
return NULL;
}
static void split_view(gboolean horizontal)
{
GtkWidget *notebook = geany_data->main_widgets->notebook;
GtkWidget *parent = gtk_widget_get_parent(notebook);
GtkWidget *pane, *toolbar, *box, *splitwin_notebook;
GeanyDocument *doc = document_get_current();
gint width = gtk_widget_get_allocated_width(notebook) / 2;
gint height = gtk_widget_get_allocated_height(notebook) / 2;
g_return_if_fail(doc);
g_return_if_fail(edit_window.editor == NULL);
set_state(horizontal ? STATE_SPLIT_HORIZONTAL : STATE_SPLIT_VERTICAL);
g_object_ref(notebook);
gtk_container_remove(GTK_CONTAINER(parent), notebook);
pane = horizontal ? gtk_hpaned_new() : gtk_vpaned_new();
gtk_container_add(GTK_CONTAINER(parent), pane);
gtk_container_add(GTK_CONTAINER(pane), notebook);
g_object_unref(notebook);
box = gtk_vbox_new(FALSE, 0);
toolbar = create_toolbar();
gtk_box_pack_start(GTK_BOX(box), toolbar, FALSE, FALSE, 0);
edit_window.vbox = box;
/* used just to make the split window look the same as the main editor */
splitwin_notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(splitwin_notebook), FALSE);
gtk_notebook_append_page(GTK_NOTEBOOK(splitwin_notebook), box, NULL);
gtk_container_add(GTK_CONTAINER(pane), splitwin_notebook);
set_editor(&edit_window, doc->editor);
if (horizontal)
{
gtk_paned_set_position(GTK_PANED(pane), width);
}
else
{
gtk_paned_set_position(GTK_PANED(pane), height);
}
gtk_widget_show_all(pane);
}
LightPathsTab::LightPathsTab(Project& project, ParamArray& settings)
: m_project(project)
, m_settings(settings)
{
setObjectName("render_widget_tab");
setLayout(new QGridLayout());
layout()->setSpacing(0);
layout()->setMargin(0);
create_light_paths_widget();
create_toolbar();
create_scrollarea();
layout()->addWidget(m_toolbar);
layout()->addWidget(m_scroll_area);
recreate_handlers();
}
myCV::myCV(cv::Mat _src_im) : src_im(_src_im){
//インスタンス作成数のカウント
cnt++;
//変数init
glayscale_flg = false;
threshold_flg = false;
edge_flg = false;
negaposi_flg = false;
flat_flg = false;
integral_flg = false;
thread_val = 255;
resize_val = 100;
//OpenCVのコントロールパネル生成
create_toolbar(cnt);
}
interface_view *
create_about_view(interface *intf, Evas_Object *parent)
{
interface_view *view = calloc(1, sizeof(*view));
/* */
view_sys *about_view_sys = calloc(1, sizeof(*about_view_sys));
about_view_sys->p_intf = intf;
about_view_sys->p_anim = malloc(sizeof(*about_view_sys->p_anim));
view->p_view_sys = about_view_sys;
/* Content box */
Evas_Object *about_box = elm_box_add(parent);
evas_object_size_hint_weight_set(about_box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(about_box, EVAS_HINT_FILL, EVAS_HINT_FILL);
/* Toolbar Naviframe */
Evas_Object *nf_toolbar = about_view_sys->nf_toolbar = elm_naviframe_add(about_box);
evas_object_size_hint_weight_set(nf_toolbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(nf_toolbar, EVAS_HINT_FILL, EVAS_HINT_FILL);
/* Create the toolbar in the view */
Evas_Object *tabbar = create_toolbar(about_view_sys);
/* Add them to the box */
elm_box_pack_end(about_box, tabbar);
evas_object_show(tabbar);
elm_box_pack_end(about_box, nf_toolbar);
evas_object_show(nf_toolbar);
/* Set the first item in the toolbar */
elm_toolbar_item_selected_set(elm_toolbar_first_item_get(tabbar), EINA_TRUE);
/* Rotation */
Evas_Object *win = intf_get_window(about_view_sys->p_intf);
evas_object_smart_callback_add(win, "wm,rotation,changed", rotation_cb, about_view_sys);
/* */
evas_object_show(about_box);
view->view = about_box;
return view;
}
static void split_view(gboolean horizontal)
{
GtkWidget *notebook = geany_data->main_widgets->notebook;
GtkWidget *parent = gtk_widget_get_parent(notebook);
GtkWidget *pane, *toolbar, *box;
GeanyDocument *doc = document_get_current();
gint width = notebook->allocation.width / 2;
gint height = notebook->allocation.height / 2;
g_return_if_fail(doc);
g_return_if_fail(edit_window.editor == NULL);
set_state(horizontal ? STATE_SPLIT_HORIZONTAL : STATE_SPLIT_VERTICAL);
gtk_widget_ref(notebook);
gtk_container_remove(GTK_CONTAINER(parent), notebook);
pane = horizontal ? gtk_hpaned_new() : gtk_vpaned_new();
gtk_container_add(GTK_CONTAINER(parent), pane);
gtk_container_add(GTK_CONTAINER(pane), notebook);
gtk_widget_unref(notebook);
box = gtk_vbox_new(FALSE, 0);
toolbar = create_toolbar();
gtk_box_pack_start(GTK_BOX(box), toolbar, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(pane), box);
edit_window.vbox = box;
set_editor(&edit_window, doc->editor);
if (horizontal)
{
gtk_paned_set_position(GTK_PANED(pane), width);
}
else
{
gtk_paned_set_position(GTK_PANED(pane), height);
}
gtk_widget_show_all(pane);
}
/**
*
* init_web_browser
*
* Initialise the webkit browser
*
* @parent: Widget to house the browser
*/
WebBrowser *init_web_browser(GtkWidget *parent) {
browser = g_new0(WebBrowser, 1);
create_menubar();
create_toolbar();
create_browser();
create_statusbar();
GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX (vbox), browser->menubar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (vbox), browser->toolbar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (vbox), browser->browser_window, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET(browser->statusbar), FALSE, FALSE, 0);
if (GTK_IS_SCROLLED_WINDOW(parent))
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(parent), vbox);
else
gtk_container_add(GTK_CONTAINER (parent), vbox);
return browser;
}
int main (int argc, char* argv[])
{
gtk_init (&argc, &argv);
GtkWidget* vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start(GTK_BOX (vbox), create_toolbar (), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (vbox), create_browser (), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX (vbox), create_statusbar (), FALSE, FALSE, 0);
main_window = create_window();
gtk_container_add(GTK_CONTAINER (main_window), vbox);
gchar* uri = (gchar*) (argc > 1 ? argv[1] : "https://github.com/CoolerVoid/");
webkit_web_view_open(web_view, uri);
gtk_widget_grab_focus(GTK_WIDGET(web_view));
gtk_widget_show_all(main_window);
gtk_main();
return 0;
}
MainWindow::MainWindow():
window_(nullptr),
source_view_(nullptr) {
window_ = new Gtk::Window();
source_view_ = Gtk::manage(new Gsv::View());
source_view_->set_show_line_numbers(true);
source_view_->set_tab_width(4);
source_view_->set_auto_indent(true);
source_view_->set_insert_spaces_instead_of_tabs(true);
source_view_->set_highlight_current_line(true);
// source_view_->set_draw_spaces(true);
source_view_->override_font(Pango::FontDescription("monospace"));
main_viewport_.add(*source_view_);
source_pane_.pack_start(nav_bar_, false, false);
source_pane_.pack_start(main_viewport_);
main_layout_.pack_start(toolbar_, false, false);
main_layout_.pack_start(source_pane_);
window_->add(main_layout_);
window_->signal_delete_event().connect(sigc::mem_fun(this, &MainWindow::on_delete_event));
window_->set_size_request(800, 600);
create_toolbar();
buffer_manager_.reset(new BufferManager(*source_view_));
//populate_navbar(os::path::expand_user("~"));
/* nav_bar_.append(nav_bar_directory_);
nav_bar_directory_.set_submenu(nav_bar_browse_menu_);*/
nav_bar_.get_directory_menu().signal_file_clicked().connect(sigc::mem_fun(this, &MainWindow::open_file));
window_->show_all();
}
int main( int argc, char **argv ) {
gtk_init( &argc, &argv );
GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( window ), "Toolbar" );
gtk_container_set_border_width( GTK_CONTAINER( window ), 10 );
gtk_widget_set_size_request( window, 325, -1 );
g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( gtk_main_quit ),
NULL );
GtkWidget *entry = gtk_entry_new();
GtkWidget *toolbar = gtk_toolbar_new();
create_toolbar( toolbar, entry );
GtkWidget *vbox = gtk_vbox_new( FALSE, 5 );
gtk_box_pack_start_defaults( GTK_BOX( vbox ), toolbar );
gtk_box_pack_start_defaults( GTK_BOX( vbox ), entry );
gtk_container_add( GTK_CONTAINER( window ), vbox );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
WINCESdlGraphicsManager::WINCESdlGraphicsManager(SdlEventSource *sdlEventSource, SdlWindow *window)
: SurfaceSdlGraphicsManager(sdlEventSource, window),
_panelInitialized(false), _noDoubleTapRMB(false), _noDoubleTapPT(false),
_toolbarHighDrawn(false), _newOrientation(0), _orientationLandscape(0),
_panelVisible(true), _saveActiveToolbar(NAME_MAIN_PANEL), _panelStateForced(false),
_canBeAspectScaled(false), _scalersChanged(false), _saveToolbarState(false),
_mouseBackupOld(NULL), _mouseBackupDim(0), _mouseBackupToolbar(NULL),
_usesEmulatedMouse(false), _forceHideMouse(false), _freeLook(false),
_hasfocus(true), _zoomUp(false), _zoomDown(false) {
memset(&_mouseCurState, 0, sizeof(_mouseCurState));
if (_isSmartphone) {
_mouseCurState.x = 20;
_mouseCurState.y = 20;
}
loadDeviceConfigurationElement("repeatTrigger", _keyRepeatTrigger, 200);
loadDeviceConfigurationElement("repeatX", _repeatX, 4);
loadDeviceConfigurationElement("repeatY", _repeatY, 4);
loadDeviceConfigurationElement("stepX1", _stepX1, 2);
loadDeviceConfigurationElement("stepX2", _stepX2, 10);
loadDeviceConfigurationElement("stepX3", _stepX3, 40);
loadDeviceConfigurationElement("stepY1", _stepY1, 2);
loadDeviceConfigurationElement("stepY2", _stepY2, 10);
loadDeviceConfigurationElement("stepY3", _stepY3, 20);
ConfMan.flushToDisk();
_isSmartphone = CEDevice::isSmartphone();
// Query SDL for screen size and init screen dependent stuff
OSystem_WINCE3::initScreenInfos();
create_toolbar();
_hasSmartphoneResolution = CEDevice::hasSmartphoneResolution() || CEDevice::isSmartphone();
if (_hasSmartphoneResolution)
_panelVisible = false; // init correctly in smartphones
_screen = NULL;
}
int
main (int argc, char* argv[])
{
gtk_init (&argc, &argv);
if (!g_thread_supported ())
g_thread_init (NULL);
GtkWidget* vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), create_toolbar (), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), create_browser (), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), create_statusbar (), FALSE, FALSE, 0);
main_window = create_window ();
gtk_container_add (GTK_CONTAINER (main_window), vbox);
gchar* uri = (gchar*) (argc > 1 ? argv[1] : "http://www.google.com/");
webkit_web_view_load_uri (web_view, uri);
gtk_widget_grab_focus (GTK_WIDGET (web_view));
gtk_widget_show_all (main_window);
gtk_main ();
return 0;
}
int main(int argc, char **argv)
{
BrailleMusicEditor *editor;
// allocate the memory needed by our BrailleMusicEditor struct
editor = g_slice_new (BrailleMusicEditor);
//initialize GTK+ libraries
gtk_init(&argc, &argv);
ev_init();
// Creation of the main window
create_window("BMC",600,400, editor);
editor->vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(editor->window), editor->vbox);
//Creation of the menubar
create_menubar(editor);
gtk_box_pack_start(GTK_BOX(editor->vbox), editor->menubar, FALSE, FALSE, 0);
// Creation of the toolbar
create_toolbar(editor);
gtk_box_pack_start(GTK_BOX(editor->vbox), editor->toolbar, FALSE, FALSE, 2);
//Creation of the two text views with scrollbars
editor->hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(editor->vbox), editor->hbox);
editor->edit_scrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(editor->edit_scrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(editor->hbox),editor->edit_scrollbar, TRUE, TRUE, 5);
editor->textview=gtk_source_view_new();
//show line number
gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(editor->textview), TRUE);
g_signal_connect(gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview)), "changed", G_CALLBACK(on_text_changed), editor);
gtk_container_add(GTK_CONTAINER(editor->edit_scrollbar), editor->textview);
//lexical coloration auto update
g_signal_connect(gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview)), "changed", G_CALLBACK(coloration_update), editor);
//score view
editor->score_scrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(editor->hbox),editor->score_scrollbar, TRUE, TRUE, 5);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(editor->score_scrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
editor->score_view = ev_view_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(editor->score_scrollbar), editor->score_view);
show_score(editor);
gtk_widget_grab_focus(editor->textview);
//Creation of the message error views with scrollbar
editor->error_scrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(editor->vbox),editor->error_scrollbar, FALSE, TRUE, 0);
gtk_widget_set_size_request (editor->error_scrollbar, -1, 100);
gtk_container_set_border_width(GTK_CONTAINER(editor->error_scrollbar), 5);
editor->error_view = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(editor->error_view), FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(editor->error_scrollbar), editor->error_view);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(editor->error_scrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
// show the window
gtk_widget_show_all(editor->window);
// enter GTK+ main loop
gtk_main();
// free memory we allocated for BrailleMusicEditor struct
g_slice_free (BrailleMusicEditor, editor);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int has_rc=0;
GtkWidget *mainWin;
GtkWidget *table;
GtkWidget *menu_bar;
GtkWidget *index_page;
GtkWidget *button;
GtkWidget *label, *box, *sbox, *pbox;
GtkWidget *vseparator;
GtkWidget *post_process_button;
GtkStyle *style;
GtkWidget *gpixmap;
GdkPixmap *pixmap;
GdkBitmap *bitmap;
char title[256];
char *envhome;
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR);
textdomain (PACKAGE);
#endif
signal(SIGSEGV, crash);
#ifdef sun
__progname = argv[0];
#endif
Thumbnails.next = NULL;
Images.next=NULL;
/* Set the priority (taken from PhotoPC photopc.c) */
#ifdef linux
if (geteuid() == 0) {
struct sched_param sp;
int rc,minp,maxp;
minp=sched_get_priority_min(SCHED_FIFO);
maxp=sched_get_priority_max(SCHED_FIFO);
sp.sched_priority=minp+(maxp-minp)/2;
if ((rc=sched_setscheduler(0,SCHED_FIFO,&sp)) == -1)
fprintf(stderr,"failed to set priority\n");
}
#endif
filesel_cwd = (char *)malloc(sizeof(char)*1024);
getcwd(filesel_cwd, 1024);
strcat(filesel_cwd, "/");
/* Make sure there's a .gphoto directory in their home ---- */
envhome = getenv("HOME");
gphotoDir = (char *)malloc(sizeof(char)*(strlen(envhome)+9));
memset(gphotoDir, 0, sizeof(char)*(strlen(envhome)+9));
sprintf(gphotoDir, "%s/.gphoto", envhome);
(void)mkdir(gphotoDir, 0744);
/* Command line mode anyone? ----------------------------- */
if (argc > 1) {
command_line_mode = 1;
has_rc = load_config();
command_line(argc, argv);
} else
command_line_mode = 0;
/* Check for DISPLAY. If not set, exit */
if (!getenv("DISPLAY")) {
printf(N_("Error: $DISPLAY variable is not set\n"));
printf(N_("Please run \"gphoto -h\" for command-line options.\n"));
_exit(0);
}
fprintf(stdout,
N_("gPhoto %s (%s)\n"),
VERSION, __DATE__);
fprintf(stdout,
N_("Copyright (C) 1998-2000 Scott Fritzinger <*****@*****.**>\n\n"));
fprintf(stdout,
N_("Usage: gphoto [-h] [-c] [-n] [-s # filename] [-t # filename]\n"));
fprintf(stdout, N_(" [-d #] [-p filename] [-l filename]\n"));
gtk_init(&argc, &argv);
#if 1 /* by fujisawa */
gdk_imlib_init();
#endif
gtk_widget_push_visual(gdk_imlib_get_visual());
gtk_widget_push_colormap(gdk_imlib_get_colormap());
library_name = gtk_label_new("");
has_rc = load_config();
/* set up the main window -------------------------------- */
mainWin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_border_width(GTK_CONTAINER(mainWin), 0);
sprintf(title, "gPhoto %s", VERSION);
gtk_window_set_title(GTK_WINDOW(mainWin), title);
gtk_signal_connect(GTK_OBJECT(mainWin), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_widget_set_usize(mainWin, 730, 480);
gtk_widget_realize(mainWin);
/* set up the menu --------------------------------------- */
menu_bar = gtk_vbox_new(FALSE, 0);
create_menu(menu_bar);
gtk_widget_show_all(menu_bar);
/* button bar -------------------------------------------- */
box = gtk_hbox_new(FALSE, 0);
create_toolbar(box, mainWin);
gtk_widget_show(box);
gtk_container_border_width(GTK_CONTAINER(box), 5);
/* accelerator keys--------------------------------------- */
gtk_accel_group_attach(mainag,GTK_OBJECT(mainWin));
/* Index Page notebook ----------------------------------- */
index_page = gtk_table_new(1,1,FALSE);
gtk_widget_show(index_page);
index_window = gtk_scrolled_window_new(NULL,NULL);
index_vp=gtk_viewport_new(NULL,NULL);
gtk_container_add(GTK_CONTAINER(index_window), index_vp);
gtk_widget_show(index_vp);
gtk_widget_show(index_window);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(index_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_table_attach_defaults(GTK_TABLE(index_page),index_window,0,1,0,1);
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
label = gtk_label_new(N_("Image Index"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), index_page,
label);
sbox = gtk_hbox_new(FALSE, 5);
gtk_widget_show(sbox);
status_bar = gtk_label_new("");
gtk_widget_show(status_bar);
gtk_label_set_justify(GTK_LABEL(status_bar), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(sbox), status_bar, FALSE, FALSE, 0);
update_status("Select \"Camera->Download Index->Thumbnails\" to begin.");
progress = gtk_progress_bar_new();
gtk_widget_show(progress);
gtk_box_pack_end(GTK_BOX(sbox), progress, FALSE, FALSE, 0);
vseparator = gtk_vseparator_new();
gtk_widget_show(vseparator);
gtk_box_pack_end(GTK_BOX(sbox), vseparator, FALSE, FALSE, 0);
post_process = 0;
post_process_button = gtk_button_new();
gtk_widget_show(post_process_button);
gtk_button_set_relief(GTK_BUTTON(post_process_button),GTK_RELIEF_NONE);
gtk_signal_connect (GTK_OBJECT(post_process_button), "clicked",
GTK_SIGNAL_FUNC(post_process_change), mainWin);
gtk_box_pack_end(GTK_BOX(sbox), post_process_button, FALSE, FALSE, 0);
pbox = gtk_hbox_new(FALSE, 3);
gtk_widget_show(pbox);
gtk_container_add(GTK_CONTAINER(post_process_button), pbox);
style = gtk_widget_get_style(mainWin);
pixmap = gdk_pixmap_create_from_xpm_d(mainWin->window, &bitmap,
&style->bg[GTK_STATE_NORMAL],(gchar **)post_processing_off_xpm);
post_process_pixmap = gtk_pixmap_new(pixmap, bitmap);
gtk_widget_show(post_process_pixmap);
gtk_box_pack_start(GTK_BOX(pbox),post_process_pixmap,FALSE,FALSE,0);
label = gtk_label_new("Post Process");
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(pbox),label,FALSE,FALSE,0);
vseparator = gtk_vseparator_new();
gtk_widget_show(vseparator);
gtk_box_pack_end(GTK_BOX(sbox), vseparator, FALSE, FALSE, 0);
gtk_widget_show(library_name);
/* gtk_widget_set_usize(library_name, 200, 16);*/
gtk_label_set_justify(GTK_LABEL(library_name), GTK_JUSTIFY_LEFT);
button = gtk_button_new();
gtk_widget_show(button);
gtk_button_set_relief(GTK_BUTTON(button),GTK_RELIEF_NONE);
gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(port_dialog), NULL);
gtk_container_add(GTK_CONTAINER(button), library_name);
gtk_box_pack_end(GTK_BOX(sbox), button, FALSE, FALSE, 0);
pixmap = gdk_pixmap_create_from_xpm_d(mainWin->window, &bitmap,
&style->bg[GTK_STATE_NORMAL],
(gchar **)splash_xpm);
gpixmap = gtk_pixmap_new(pixmap, bitmap);
gtk_widget_show(gpixmap);
/* Main window layout ------------------------------------ */
table =gtk_table_new(4,1,FALSE);
gtk_container_add(GTK_CONTAINER(mainWin), table);
gtk_widget_show(table);
gtk_table_attach(GTK_TABLE(table),menu_bar, 0, 1, 0, 1,
GTK_FILL|GTK_EXPAND, GTK_FILL, 0 , 0);
gtk_table_attach(GTK_TABLE(table), box, 0, 1, 1, 2,
GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
gtk_table_attach_defaults(GTK_TABLE(table),notebook, 0, 1, 2, 3);
gtk_table_attach(GTK_TABLE(table),sbox, 0, 1, 3, 4,
GTK_FILL|GTK_EXPAND, GTK_FILL, 0 , 0);
index_table = gtk_hbox_new(FALSE, 0);
gtk_widget_show(index_table);
gtk_container_add( GTK_CONTAINER(index_vp), index_table);
gtk_box_pack_start(GTK_BOX(index_table), gpixmap, TRUE, FALSE, 0);
/* If not command-line mode... --------------------------- */
gtk_widget_show(mainWin);
if (!has_rc) {
/* put anything here to do on the first run */
developer_dialog_create();
error_dialog(
"Could not load config file.\n"
"Resetting to defaults.\n"
"Click on \"Select Port-Camera Model\n"
"in the Configure menu to set your\n"
"camera model and serial port\n");
}
gtk_main();
return 0;
}
static void
do_appwindow (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *statusbar;
GtkWidget *contents;
GtkWidget *sw;
GtkTextBuffer *buffer;
GSimpleActionGroup *action_group;
GtkBuilder *builder;
GMenuModel *model;
GtkWidget *menubar;
GtkWidget *toolbar;
/* Create the toplevel window
*/
++window_count;
aspect_on = FALSE;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Application Window");
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy_cb), NULL);
grid = gtk_grid_new ();
gtk_widget_set_vexpand (grid, TRUE);
gtk_widget_set_hexpand (grid, TRUE);
gtk_container_add (GTK_CONTAINER (window), grid);
action_group = g_simple_action_group_new ();
builder = gtk_builder_new_from_string (xml, -1);
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
demo_entries,
G_N_ELEMENTS (demo_entries),
window);
gtk_widget_insert_action_group (window, "demo", G_ACTION_GROUP (action_group));
/* Create the menubar
*/
model = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
menubar = gtk_menu_bar_new_from_model (model);
gtk_grid_attach (GTK_GRID (grid), menubar, 0, 0, 1, 1);
gtk_widget_set_hexpand (menubar, TRUE);
/* Create the toolbar
*/
toolbar = create_toolbar ();
gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 1, 1, 1);
gtk_widget_set_hexpand (toolbar, TRUE);
/* Create document
*/
contents = gtk_text_view_new ();
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_grid_attach (GTK_GRID (grid), sw, 0, 2, 1, 1);
gtk_widget_set_hexpand (sw, TRUE);
gtk_widget_set_vexpand (sw, TRUE);
gtk_window_set_default_size (GTK_WINDOW (window),
200, 200);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),
PANGO_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (sw),
contents);
/* Create statusbar
*/
statusbar = gtk_statusbar_new ();
gtk_grid_attach (GTK_GRID (grid), statusbar, 0, 3, 1, 1);
gtk_widget_set_hexpand (statusbar, TRUE);
/* Show text widget info in the statusbar */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
gtk_text_buffer_set_text (buffer,
"This demo demonstrates various kinds of windows that "
"window managers and window manager themes should handle. "
"Be sure to tear off the menu and toolbar, those are also "
"a special kind of window.",
-1);
g_signal_connect_object (buffer,
"changed",
G_CALLBACK (update_statusbar),
statusbar,
0);
g_signal_connect_object (buffer,
"mark_set", /* cursor moved */
G_CALLBACK (mark_set_callback),
statusbar,
0);
update_statusbar (buffer, GTK_STATUSBAR (statusbar));
gtk_widget_show_all (window);
g_object_unref (action_group);
g_object_unref (builder);
}
GtkWindow*
create_ui ()
{
GtkWindow *window = g_object_new (GTK_TYPE_WINDOW, NULL);
gtk_window_set_title (window, "Folding Tab Pane demo ");
gtk_window_maximize (window);
GtkBox *vbox, *hbox, *vbox_main;
hbox = GTK_BOX (gtk_hbox_new (FALSE, 1));
vbox = GTK_BOX (gtk_vbox_new (FALSE, 1));
vbox_main = GTK_BOX (gtk_vbox_new (FALSE, 1));
GtkWidget *left_pane, *right_pane, *top_pane, *bottom_pane;
GtkWidget *text_area, *scroll_pane;
left_pane = g_object_new (FOLDING_TAB_PANE_TYPE,
"tab-pos", GTK_POS_LEFT,
NULL);
right_pane = g_object_new (FOLDING_TAB_PANE_TYPE,
"tab-pos", GTK_POS_RIGHT,
NULL);
top_pane = g_object_new (FOLDING_TAB_PANE_TYPE,
"tab-pos", GTK_POS_TOP,
NULL);
bottom_pane = g_object_new (FOLDING_TAB_PANE_TYPE,
"tab-pos", GTK_POS_BOTTOM,
NULL);
/* set as custom data to window */
g_object_set_data (G_OBJECT (window), FOLDING_TAB_PANE_LEFT, left_pane);
g_object_set_data (G_OBJECT (window), FOLDING_TAB_PANE_RIGHT, right_pane);
g_object_set_data (G_OBJECT (window), FOLDING_TAB_PANE_TOP, top_pane);
g_object_set_data (G_OBJECT (window), FOLDING_TAB_PANE_BOTTOM, bottom_pane);
GtkWidget *toolbar = create_toolbar (GTK_WIDGET (window));
/* Create panels */
text_area = gtk_text_view_new ();
scroll_pane = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll_pane),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scroll_pane), text_area);
gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (vbox_main));
gtk_box_pack_start (vbox_main, toolbar,
FALSE, FALSE, 0);
gtk_box_pack_end (vbox_main, GTK_WIDGET (hbox),
TRUE, TRUE, 0);
gtk_box_pack_start (hbox, left_pane,
FALSE, FALSE, 0);
gtk_box_pack_start (hbox, GTK_WIDGET (vbox),
TRUE, TRUE, 0);
gtk_box_pack_end (hbox, right_pane,
FALSE, FALSE, 0);
gtk_box_pack_start (vbox, top_pane,
FALSE, FALSE, 0);
gtk_box_pack_start (vbox, scroll_pane,
TRUE, TRUE, 0);
gtk_box_pack_end (vbox, bottom_pane,
FALSE, FALSE, 0);
/* Add one tab to the left pane to test tab inserting before window realizing */
GtkWidget *scroll = gtk_scrolled_window_new (NULL, NULL);
GtkWidget *text_view = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (scroll), text_view);
folding_tab_pane_append_page (FOLDING_TAB_PANE (left_pane),
gtk_text_view_new (), gtk_label_new ("left pane 2"));
g_signal_connect (window,
"destroy",
G_CALLBACK (application_shutdown),
NULL);
/* connect signals to panes for page-added, page-removed and switch-page events
Will log this events to the central TextView */
connect_pane_events (left_pane, text_area);
return window;
}
static void
create_normal_browser_window(struct gui_window *gw, int furniture_width)
{
fbtk_widget_t *widget;
fbtk_widget_t *toolbar;
int statusbar_width = 0;
int toolbar_height = nsoption_int(fb_toolbar_size);
LOG(("Normal window"));
gw->window = fbtk_create_window(fbtk, 0, 0, 0, 0, 0);
statusbar_width = nsoption_int(toolbar_status_size) *
fbtk_get_width(gw->window) / 10000;
/* toolbar */
toolbar = create_toolbar(gw,
toolbar_height,
2,
FB_FRAME_COLOUR,
nsoption_charp(fb_toolbar_layout));
/* set the actually created toolbar height */
if (toolbar != NULL) {
toolbar_height = fbtk_get_height(toolbar);
} else {
toolbar_height = 0;
}
/* status bar */
gw->status = fbtk_create_text(gw->window,
0,
fbtk_get_height(gw->window) - furniture_width,
statusbar_width, furniture_width,
FB_FRAME_COLOUR, FB_COLOUR_BLACK,
false);
fbtk_set_handler(gw->status, FBTK_CBT_POINTERENTER, set_ptr_default_move, NULL);
LOG(("status bar %p at %d,%d", gw->status, fbtk_get_absx(gw->status), fbtk_get_absy(gw->status)));
/* create horizontal scrollbar */
gw->hscroll = fbtk_create_hscroll(gw->window,
statusbar_width,
fbtk_get_height(gw->window) - furniture_width,
fbtk_get_width(gw->window) - statusbar_width - furniture_width,
furniture_width,
FB_SCROLL_COLOUR,
FB_FRAME_COLOUR,
fb_scroll_callback,
gw);
/* fill bottom right area */
if (nsoption_bool(fb_osk) == true) {
widget = fbtk_create_text_button(gw->window,
fbtk_get_width(gw->window) - furniture_width,
fbtk_get_height(gw->window) - furniture_width,
furniture_width,
furniture_width,
FB_FRAME_COLOUR, FB_COLOUR_BLACK,
fb_osk_click,
NULL);
widget = fbtk_create_button(gw->window,
fbtk_get_width(gw->window) - furniture_width,
fbtk_get_height(gw->window) - furniture_width,
furniture_width,
furniture_width,
FB_FRAME_COLOUR,
&osk_image,
fb_osk_click,
NULL);
} else {
widget = fbtk_create_fill(gw->window,
fbtk_get_width(gw->window) - furniture_width,
fbtk_get_height(gw->window) - furniture_width,
furniture_width,
furniture_width,
FB_FRAME_COLOUR);
fbtk_set_handler(widget, FBTK_CBT_POINTERENTER, set_ptr_default_move, NULL);
}
/* create vertical scrollbar */
gw->vscroll = fbtk_create_vscroll(gw->window,
fbtk_get_width(gw->window) - furniture_width,
toolbar_height,
furniture_width,
fbtk_get_height(gw->window) - toolbar_height - furniture_width,
FB_SCROLL_COLOUR,
FB_FRAME_COLOUR,
fb_scroll_callback,
gw);
/* browser widget */
create_browser_widget(gw, toolbar_height, nsoption_int(fb_furniture_size));
/* Give browser_window's user widget input focus */
fbtk_set_focus(gw->browser);
}
LRESULT APIENTRY MainWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_CREATE:
create_toolbar(hwnd);
create_term(hwnd);
create_sysmenu(hwnd);
return 0;
case WM_SIZE:
SendMessage(wndTB, TB_AUTOSIZE, 0, 0);
get_def_size(LOWORD(lParam), HIWORD(lParam));
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case BUT_OPEN:
open_file();
break;
case BUT_REWIND:
but_rewind:
if (play_state==-1)
break;
EnterCriticalSection(&vt_mutex);
replay_pause();
tr.tv_sec=0;
tr.tv_usec=0;
set_prog();
replay_seek();
LeaveCriticalSection(&vt_mutex);
play_state=1;
replay_resume();
do_replay();
break;
case BUT_PAUSE:
if (play_state==1)
goto but_unpause;
but_pause:
CancelWaitableTimer(timer);
replay_pause();
set_buttons(1);
break;
case BUT_PLAY:
if (play_state>1)
goto but_pause;
but_unpause:
replay_resume();
do_replay();
set_buttons(1);
break;
case BUT_SELSTART:
if (play_state==-1)
break;
get_pos();
selstart=tr;
set_prog_sel();
break;
case BUT_SELEND:
if (play_state==-1)
break;
selend=tr;
set_prog_sel();
break;
case BUT_EXPORT:
if (play_state==-1)
break;
if (tcmp(selstart, selend)>=0)
break;
export_file();
break;
}
return 0;
case WM_SYSCOMMAND:
switch (LOWORD(wParam))
{
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
case BUT_FONT:
choose_font();
}
return 0;
case WM_HSCROLL:
if ((HANDLE)lParam==wndSpeed)
speed_scrolled();
else if ((HANDLE)lParam==wndProg)
prog_scrolled();
return 0;
case WM_KEYDOWN:
switch (wParam)
{
case VK_ADD:
case 'F':
adjust_speed(+1);
break;
case VK_SUBTRACT:
case 'S':
adjust_speed(-1);
break;
case '1':
SendMessage(wndSpeed, TBM_SETPOS, 1, 2);
speed_scrolled();
break;
case 'Q':
DestroyWindow(wndMain);
break;
case 'O':
open_file();
break;
case VK_SPACE:
switch (play_state)
{
case -1:
open_file();
break;
case 0:
play_state=2;
goto but_rewind;
case 1:
goto but_unpause;
case 2:
case 3:
goto but_pause;
}
break;
case 'R':
goto but_rewind;
break;
case VK_RIGHT:
adjust_pos(+10);
break;
case VK_LEFT:
adjust_pos(-10);
break;
case VK_UP:
adjust_pos(+60);
break;
case VK_DOWN:
adjust_pos(-60);
break;
case VK_PRIOR:
adjust_pos(+600);
break;
case VK_NEXT:
adjust_pos(-600);
break;
}
return 0;
case WM_SIZING:
constrain_size((LPRECT)lParam);
return 1;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
GtkWidget *
do_css_shadows (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *paned, *container, *child;
GtkStyleProvider *provider;
GtkTextBuffer *text;
GBytes *bytes;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Shadows");
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (window), paned);
child = create_toolbar ();
gtk_container_add (GTK_CONTAINER (paned), child);
text = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text,
"warning",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_create_tag (text,
"error",
"underline", PANGO_UNDERLINE_ERROR,
NULL);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
container = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (paned), container);
child = gtk_text_view_new_with_buffer (text);
gtk_container_add (GTK_CONTAINER (container), child);
g_signal_connect (text, "changed",
G_CALLBACK (css_text_changed), provider);
bytes = g_resources_lookup_data ("/css_shadows/gtk.css", 0, NULL);
gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
g_bytes_unref (bytes);
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (show_parsing_error),
gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
