GUI Syntax for Modern C++

AI in economy

House boat management

Research Direction

Clearlinux, wayland, gentoo wayland, skia, uxdev

Carla an audio VST plugin host system, would be served well as an applet controlling the plugin chain for audio output on some systems that are playing movies. I wanted to try to get it to work on my new system setup, source compiling and found within lmms problms compiling the entire suite to also use the gcc windows compiler. The system could offer Musical doodles from application creation contexts within the file browser for example. A next generation desktop. Next Gen Desktops. The numerious stages involved in music production becomes an interesting field for many. With the ability to interact with the media, midi, tracks, and mixing, the parameters are combined within multiple layers and specialed interfaces sudh as adore, protools, VST, LV2 and digital signal hosting providers. A user downloads a midi file, along with the vocals, and instrument samples, video, the artists new portfolio. The user mixes the drums, and can change a pattern from the prospective of a fan. Mod the song, and reprint it to the network relying on the same DRM services to apply benefits.


More research within the gentoo namespace. Providing package delivery as a unit usch as a bootable stick has not been accomplished with gentoo. Currently the development environment is being setup with gentoo. The next project after composition and evaluation models will provide the capability of using meson, and building output for multiple targets such as bootable medium, and application layer. The encompassing rendering technologies provided as an easy api with a dialect that transverses accross rendering platforms while not standing in the way of the library itself will be a useful programming construct. The proposition of using multiple tui back ends, ncurses and others provides a means of easy development. The capability for selection and operating platform modules with their respective command line modes provides staging of application architecture and modeling features most rapidly for development.

The growth pattern is that the interface becomes more descriptive while construction idioms of ui interfaces provide target translation. For example, using images rendered in ascii art (color summary and graphic density exposure) in text as a mouse over [IMG:AltName] provides full screen representation for the abstract. Or layout mechanism provide verticle scrolling only while gui rendering of the interface composition may provide discreet positioning.

Many of the technologies are simular on their level while within the set of offered capabilities of a base feature such as line drawing that are not only horizontal or verticle should be modeled as a bit. The usage of the stdbit set will most likely encompas the functionality and expansion. However, within each set there will be relatating bitsets which are modeled within the header file of the platform_module that describe the specific capabilities. This leaves room for senthesis mechanisms which provide layers that are not supported within the base.

The architecture of the platform model shall also provide translation of events from the base system to the object.listen<> model. However, there are still some discovereies how to translate. At times some libraries provide a low level input interface in broadcasting the event data. While some libraries such as GTKmm/GDKmm provide application level data message as well as low level data.

The platform model also provides the application of specific combinations of technology usage allowing the underlying code and binary module to be as compact as possible. For example, amongst the plentiful model of exposed shared libraries, the skia_GLFW provides a GLFW window and platform creation mechanism inlined, generated by option, cross platform, provides an opengl window. Skia wraps the glwindow with its api to provide results. The combinations provide dynamic memory usage.

The GTKmm application model, GTKgl, provides a rich widget library. As well technologies exist such as Dazzle which use the GTKmm library to provide application features. Some libraries provide native sound and operating system integration like elementary does. Although some of elementary and glib,gio has been instanation with base std features such as threading. The usage of the boost model also provides models for platform data manulipations. Such as the ability to traverse and organize data structures for formatted output.

The boost spirit parser provides the capability of BNF parsing as to incorpoate the HTML model fully. There are methods already and libraries in existance to provide this.

The most platform module components are libraries that provide three dimensional screen graph technologies such as geometrictools.com, panda3d, and orge. The total list is expressive and dynamic.

Bootable image production, imagemagick, librsvg, libpango, and installation package such as android, linux, mac and chipset, feature selection (mouse, keyboard, level, joystick, touch) all lend to the fact the number of combinations are great. A GUI build tool that uses meson build system that provides the selection features. While for the client code application it is interfaced as a standard c++ application is most likely the necessity. There are many GUI and graphical systems, sources, building procedures, etc so an interface is necessary. Python program which instaniates the procedures of source capture and build. The ability to download the source, documentation, compiled to a gtk doc or boost doc for library reference, building example programs checkbox and removal.

An operating system system in research is a new type of boxed kernel with running states that reduce code and maintain usage based on historial operation preferences using LLVM. As well most settings and user preferences are compiled within the resulting footprint. The best thing is the style and easy operating modes giving the user context within their life. Usage traits and systems that are tailored for user with standard age based interfaces. Cordial budget organizer for family members spending online with game rentals. 10 Free quality games and expexted base software that is designed with the next generation UI technology that is enabled by LLVM. Magnification and minification upon interaction and eye blink clicking. Robotic control and trusted user device connectivity. Automated backup life.


Several research source projects are available:

UXDEV

UXDEV source code

status in progress research - source code backup repository.

Is a code base providing template oriented deisgn to support multiple platform bases. The structure is at its infancy. The prototype illustrates two windows running the same basic application using a simular dialect. The system is designed such that event code is written in the form of the platform base. This provides the growth support pattern between the two. An event translator can provide the operating of a program compiled for one mode to operate in another. Compilation is also cross platform.



#include "ux/api.h"
#include "ux/gui_sfml/platform.h"
#include "ux/tui_ncurses/platform.h"

using namespace uxdev;

#define STR1 "Hello World."
#define STR2 "And of course location. Add attributes and element object parser."

int main(int argc, char **argv) {
  auto mw = window_t({}, "Test");
  auto mw2 = window_t({}, "Test");

  mw(10, 10) << STR1;
  mw(2, 2) << STR2;

  mw2(10, 10) << STR1;
  mw2(2, 2) << STR2;

  // events are the same class or type as the interface base
  // this provides programming using the coverage and event system of the base.
  // The syntax provides explicit nature of usage within the platform interface
  // base and technology. After compilation, with the use of exported functions
  // within the executable, it is hoped that upstream and downstream operation
  // is possible. event translation between the system will be necessary,
  sf::Event evt = {};
  evt.type = sf::Event::KeyPressed;
  evt.key.code = sf::Keyboard::Escape;

  mw.listen(evt, [&](auto evt) {
    mw(5, 5) << "keypressed " << evt.key.code;
    return true;
  });

  mw2.listen(KEY_ENTER, [&](auto evt) {
    mw2(5, 5) << "keypressed " << evt;
    return true;
  });

  mw.wait_for_exit();
  mw2.wait_for_exit();

  return EXIT_SUCCESS;
}
    


PLATFORM_OBJ

PLATFORM_OBJ source code

status in progress research - source code backup repository.

Is a code base research project which uses cairo graphics, pango text layout engine, and ties them together in an easy to use stream based object input. The objects are persistent and can be modified. Hashing is performed on all on screen items to detect changes. Static members may be allocated which exclude this functionality for performance increases.


#include "uxdevice.hpp"

using namespace std;
using namespace uxdevice;

void show_time(surface_area &vis, double x, double y);
std::string generate_text(void);

void event_dispatch(const event &evt);
void handle_error(const std::string errText) {
  fprintf(stderr, "%s", errText.data());
}


/****************************************************************************************************
***************************************************************************************************/

#if defined(__linux__)
int main(int argc, char **argv) {
  // handle command line here...
#elif defined(_WIN64)
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
                   LPSTR lpCmdLine, int /* nCmdShow */) {
  // command line
#endif


  surface_area vis = surface_area({500, 500}, "Information Title",
                                  painter_brush_t("darkgreen"));

  std::shared_ptr<std::string> paragraph_text =
      std::make_shared<std::string>("starting text");

  // easily index  properties for specific access later.
  // creating shared objects allows for some interface architectures
  // to be crafted easier.
  vis << text_font("28px").index("paragraphfont");
  vis << text_shadow("green") << coordinates{0, 100, 600, 300}
      << text_color("white") << paragraph_text << '\n';

  vis[paragraph_text] =
      "New text is applied without an indirect index, more simplified syntax. ";
  vis["paragraphfont"] = "40px";



  vis.notify_complete();
  while (vis.processing()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(DRAW_SLEEP));

    show_time(vis, 0, 0);
    vis[paragraph_text] = generate_text();
    vis.notify_complete();
  }

  return 0;
}

void show_time(surface_area &vis, double x, double y) {
  std::time_t t = std::time(nullptr);
  char mbstr[100];
  std::strftime(mbstr, sizeof(mbstr), "%A %c", std::localtime(&t));

  vis << text_fill_off() << text_outline_off() << text_font("28px")
      << text_shadow("darkgrey") << coordinates{x, y, 600, 300}
      << text_color(0, 0, 10, 10, {{"white"}, {"grey"}}) << mbstr << "  "
      << '\n';
}


std::string generate_text(void) {
  std::string ret;

  std::uniform_int_distribution<> info(1, 5);
  switch (info(gen)) {
  case 1:
    ret = "Silver colored crafts from another galaxy seem "
          "curiously welcomed as the memorizing audio waves "
          "produced a canny type of music. A simple ten note. ";
    break;
  case 2:
    ret = "The color of text can be a choice. Yet the appearance is also a "
          "common "
          "desire. Creating animal letters colored with a furry texture is "
          "great for CPU rendering work. Perhaps the flexibility of the API "
          "gives "
          "light to incorporating other types of computer generated graphics. ";
    break;
  case 3:
    ret = "Planets orbit the mass, but this is inconsequential of "
          "the heat provided. As children, we find a balance. ";
    break;
  case 4:
    ret = "The sun sets casting its refraction upon the mountain side. ";
    break;
  case 5:
    ret =
        "The sun sets casting its refraction upon the mountain side. "
        "The glistening oil coats upon the ravens are a remark of healthiness. "
        "One that is pronounced during the day and in the moonlight. "
        "At home, a cave dweller sees this all at once. These are indeed fine "
        "things. "
        "The warmth of the sun decays as thousands of brilliant stars dictate "
        "the continual persistence of the system.  A remarkable sight. A "
        "heavenly home.";
    break;
  }
  return ret;
}



CPPUX

Status : compiling, non functional. Researching other methods. Perhaps less terse is better. A styling engine that is easy to use should contain a dictionary of styles with specific summarized enumerated options. Perhaps a numerical value input consisting of two fields. It seems that the heirarchy building takes a lot of detailed description. I might solve these problems differently more closely with the standard. Better discovered methods exist within the context of a styling engine.

CPPUX source code

This project is a research API for the C++ 17 and above language to provide a document object model. The product is designed to be cross platform. Currently the macOS, iOS, and Android NDK library needs research. The template dom library works precisely with the standard library without adding new data types. It supports rapid development and incorporates a small set of memorable names within its model. It is a templated oriented implementation for higher performance and integrated syntax. It offers the document object model integrated with C++ language as a natural syntax that appears like HTML because of the use of <>. The following development platforms and rendering technologies are capable of use for development and distribution.

Supported C++ compilers

Rendering Engines

There are numerous possibilities for the model's occupancy within the developer’s toolbox. The system provides these capabilities through well documented preprocessor definitions. That is, compiling for each of these types of environments is established as simply turning a definition on or off. Some of these project types require third party libraries for linking. Optionally linking can be static or runtime dynamic.


      #include "viewManager.hpp"
      using namespace std;
      using namespace ViewManager;

      #if defined(__linux__)int main(int argc, char **argv) {
      // handle command line here...
      #elif defined(_WIN64)int WINAPI WinMain(HINSTANCE /* hInstance */, HINSTANCE /* hPrevInstance */,                   
            LPSTR lpCmdLine, int /* nCmdShow */) {
            // command line
       #endif 

       auto &vm = createElement(
              objectTop{10_pct}, objectLeft{10_pct}, objectHeight{80_pct},      
              objectWidth{80_pct}, textFace{"arial"}, textSize{16_pt}, textWeight{400},      
              textIndent{2_em}, lineHeight::normal, textAlignment::left,      
              position::relative, paddingTop{5_pt}, paddingLeft{5_pt},      
              paddingBottom{5_pt}, paddingRight{5_pt}, marginTop{5_pt},      
              marginLeft{5_pt}, marginBottom{5_pt}, marginRight{5_pt});  

              vm << "Hello World\n";  
              vm.render();
        }

PLATFORM

status : research code base.

PLATFORM source code

Is a code base that is method and public member oriented. Some functionality exists. It is the pre code base to the PLATFORM_OBJ project. Using cairo graphics, pango with xcb. Some events even work.



#include "uxdevice.hpp"

using namespace std;
using namespace uxdevice;

void drawText(platform &vis, double dStep, bool bfast);


void eventDispatch(const event &evt);
void handleError(const std::string errText) {
  fprintf(stderr, "%s", errText.data());
}

/****************************************************************************************************
***************************************************************************************************/
#if defined(__linux__)
int main(int argc, char **argv) {
  // handle command line here...
#elif defined(_WIN64)
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
                   LPSTR lpCmdLine, int /* nCmdShow */) {
  // command line
#endif

  // create the main window area. This may this is called a Viewer object.
  // The main browsing window. It is an element as well.
  auto vis = platform(eventDispatch, handleError);

  // starts rendering and message threads
  // parameter notes frame per second
  vis.startProcessing();
 

  vis.openWindow(
      "Information Title", 500, 600,
      Paint("blue"));


  while (vis.processing()) {
	vis.clear();
	vis.font("50px");
	vis.textShadow("black");
	vis.textAlignment(alignment::left);
	vis.textFill("white");
	vis.textOutline("lightgrey");
	vis.text("Silver colored crafts from another galaxy seem "
		"curiously welcomed as the memorizing audio waves "
		"produced a canny type of music. A simple ten note. ");
	vis.drawText(); 
	vis.notifyComplete();
    
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
  }

  return 0;
}
    
    

PLATFORM_MIN

status : research project.

PLATFORM_MIN source code

Is a code base that implements FREETYPE and pixel drawing of characters to xcb and direct x frame buffer. It hase logic to perform word wrapping using std data structures.


#include "uxdevice.hpp"

using namespace std;
using namespace uxdevice;


eventHandler eventDispatch(const event &evt);

/****************************************************************************************************
***************************************************************************************************/
#if defined(__linux__)
int main(int argc, char **argv) {
  // handle command line here...
#elif defined(_WIN64)
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
                   LPSTR lpCmdLine, int /* nCmdShow */) {
  // command line
#endif

  // create the main window area. This may this is called a Viewer object.
  // The main browsing window. It is an element as well.
  auto vis = platform(eventDispatch);
  vis.openWindow("test app", 800, 600);

  // for the display list, only pointers are used.
  // this enables the changing of data without any copy.
  // all data from the uxdevice is external from it.
  // The shared pointer is used.
  // typically an api is used to fill these structures.
  auto coordinates = make_shared<rectangle>(10, 10, 300, 300);
  auto textInfo = make_shared<string>("client data");
  auto color = make_shared<unsigned int>(0x00);
  auto ptSize = make_shared<int>(10);
  auto aln = make_shared<char>('l');
  auto tf = make_shared<string>("arial");
  auto idx1 = make_shared<size_t>(0);
  auto idx2 = make_shared<size_t>(textInfo->size());

  vis.data().push_back(stringData{textInfo});
  vis.data().push_back(textFace{tf, ptSize});
  vis.data().push_back(textColor{color});
  vis.data().push_back(textAlignment{aln});
  vis.data().push_back(targetArea{coordinates});
  vis.data().push_back(drawText{idx1, idx2});

  stringstream ss;
  for(int i=0;i<100;i++) {
    ss << "Info " << i << " 0876543&*^%$##  5555555555555555hhh]\tttttthhhhhhhhhhhjjjjjjjjjjjjjjjjjjjj\n";
  }

  auto coordinates2 = make_shared<rectangle>(30, 30, 600, 600);
  auto color2 = make_shared<unsigned int>(0x0000ff);
  auto textInfo2 = make_shared<string>(ss.str());
  auto idx1b = make_shared<size_t>(0);
  auto idx2b = make_shared<size_t>(textInfo2->size());

  vis.data().push_back(stringData{textInfo2});
  vis.data().push_back(textColor{color2});
  vis.data().push_back(targetArea{coordinates2});
  vis.data().push_back(drawText{idx1b, idx2b});


  auto coordinates3 = make_shared<rectangle>(200, 200, 500, 500);
  //auto imageFileName = make_shared<string>("/home/anthony/source/nanosvg/example/drawing.svg");
  auto imageFileName = make_shared<string>("/home/anthony/source/nanosvg/example/screenshot-2.png");
//  auto imageFileName = make_shared<string>("plasma:fractal");
  vis.data().push_back(targetArea{coordinates3});
  vis.data().push_back(imageData{imageFileName});
  vis.data().push_back(drawImage{});


  auto coordinates4 = make_shared<rectangle>(400, 200, 900, 500);
  //auto imageFileName = make_shared<string>("/home/anthony/source/nanosvg/example/drawing.svg");
  auto imageFileName2 = make_shared<string>("/home/anthony/source/nanosvg/example/draw.png");
  vis.data().push_back(targetArea{coordinates4});
  vis.data().push_back(imageData{imageFileName2});
  vis.data().push_back(drawImage{});

  vis.dirty(0);
  int width = vis.pixelWidth(0);
  int height = vis.pixelHeight(0);
  vis.processEvents();

  test0(vis);
}

eventHandler eventDispatch(const event &evt) {}

/************************************************************************
************************************************************************/
void test0(platform &vm) {}
    
    
© 2019-2021 Anthony Matarazzo


www.000webhost.com